]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
initialize GdkColor so code which incorrectly accesses it will work as well as it...
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2516 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2517 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2518 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2519 #define SWIGTYPE_p_wxImage swig_types[57]
2520 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2521 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2522 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2523 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2524 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2525 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2526 #define SWIGTYPE_p_wxInputStream swig_types[64]
2527 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2528 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2529 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2530 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2531 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2532 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2533 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2534 #define SWIGTYPE_p_wxMenu swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2536 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2537 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2539 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2541 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2544 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2545 #define SWIGTYPE_p_wxObject swig_types[83]
2546 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2547 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2550 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2552 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2553 #define SWIGTYPE_p_wxPoint swig_types[91]
2554 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2555 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2556 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2557 #define SWIGTYPE_p_wxPyApp swig_types[95]
2558 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2560 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2561 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2563 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2564 #define SWIGTYPE_p_wxPySizer swig_types[102]
2565 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2566 #define SWIGTYPE_p_wxQuantize swig_types[104]
2567 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2568 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2569 #define SWIGTYPE_p_wxRect swig_types[107]
2570 #define SWIGTYPE_p_wxRegion swig_types[108]
2571 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2572 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2574 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSize swig_types[113]
2576 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2577 #define SWIGTYPE_p_wxSizer swig_types[115]
2578 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2580 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2581 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2582 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2583 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2584 #define SWIGTYPE_p_wxToolTip swig_types[122]
2585 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2586 #define SWIGTYPE_p_wxValidator swig_types[124]
2587 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2588 #define SWIGTYPE_p_wxWindow swig_types[126]
2589 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2590 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2591 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2592 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2593 static swig_type_info *swig_types[132];
2594 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2595 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2596 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2597
2598 /* -------- TYPES TABLE (END) -------- */
2599
2600 #if (PY_VERSION_HEX <= 0x02000000)
2601 # if !defined(SWIG_PYTHON_CLASSIC)
2602 # error "This python version requires to use swig with the '-classic' option"
2603 # endif
2604 #endif
2605 #if (PY_VERSION_HEX <= 0x02020000)
2606 # error "This python version requires to use swig with the '-nomodern' option"
2607 #endif
2608 #if (PY_VERSION_HEX <= 0x02020000)
2609 # error "This python version requires to use swig with the '-nomodernargs' option"
2610 #endif
2611 #ifndef METH_O
2612 # error "This python version requires to use swig with the '-nofastunpack' option"
2613 #endif
2614
2615 /*-----------------------------------------------
2616 @(target):= _core_.so
2617 ------------------------------------------------*/
2618 #define SWIG_init init_core_
2619
2620 #define SWIG_name "_core_"
2621
2622 #define SWIGVERSION 0x010329
2623
2624
2625 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2626 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2627
2628
2629 #include <stdexcept>
2630
2631
2632 namespace swig {
2633 class PyObject_ptr {
2634 protected:
2635 PyObject *_obj;
2636
2637 public:
2638 PyObject_ptr() :_obj(0)
2639 {
2640 }
2641
2642 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2643 {
2644 Py_XINCREF(_obj);
2645 }
2646
2647 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2648 {
2649 if (initial_ref) Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr & operator=(const PyObject_ptr& item)
2653 {
2654 Py_XINCREF(item._obj);
2655 Py_XDECREF(_obj);
2656 _obj = item._obj;
2657 return *this;
2658 }
2659
2660 ~PyObject_ptr()
2661 {
2662 Py_XDECREF(_obj);
2663 }
2664
2665 operator PyObject *() const
2666 {
2667 return _obj;
2668 }
2669
2670 PyObject *operator->() const
2671 {
2672 return _obj;
2673 }
2674 };
2675 }
2676
2677
2678 namespace swig {
2679 struct PyObject_var : PyObject_ptr {
2680 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2681
2682 PyObject_var & operator = (PyObject* obj)
2683 {
2684 Py_XDECREF(_obj);
2685 _obj = obj;
2686 return *this;
2687 }
2688 };
2689 }
2690
2691
2692 #include "wx/wxPython/wxPython_int.h"
2693 #include "wx/wxPython/pyclasses.h"
2694 #include "wx/wxPython/twoitem.h"
2695
2696
2697 #ifndef wxPyUSE_EXPORT
2698 // Helper functions for dealing with SWIG objects and such. These are
2699 // located here so they know about the SWIG types and functions declared
2700 // in the wrapper code.
2701
2702 #include <wx/hashmap.h>
2703 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2704
2705
2706 // Maintains a hashmap of className to swig_type_info pointers. Given the
2707 // name of a class either looks up the type info in the cache, or scans the
2708 // SWIG tables for it.
2709 extern PyObject* wxPyPtrTypeMap;
2710 static
2711 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2712
2713 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2714
2715 if (typeInfoCache == NULL)
2716 typeInfoCache = new wxPyTypeInfoHashMap;
2717
2718 wxString name(className);
2719 swig_type_info* swigType = (*typeInfoCache)[name];
2720
2721 if (! swigType) {
2722 // it wasn't in the cache, so look it up from SWIG
2723 name.Append(wxT(" *"));
2724 swigType = SWIG_TypeQuery(name.mb_str());
2725
2726 // if it still wasn't found, try looking for a mapped name
2727 if (!swigType) {
2728 PyObject* item;
2729 name = className;
2730
2731 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2732 (char*)(const char*)name.mbc_str())) != NULL) {
2733 name = wxString(PyString_AsString(item), *wxConvCurrent);
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736 }
2737 }
2738 if (swigType) {
2739 // and add it to the map if found
2740 (*typeInfoCache)[className] = swigType;
2741 }
2742 }
2743 return swigType;
2744 }
2745
2746
2747 // Check if a class name is a type known to SWIG
2748 bool wxPyCheckSwigType(const wxChar* className) {
2749
2750 swig_type_info* swigType = wxPyFindSwigType(className);
2751 return swigType != NULL;
2752 }
2753
2754
2755 // Given a pointer to a C++ object and a class name, construct a Python proxy
2756 // object for it.
2757 PyObject* wxPyConstructObject(void* ptr,
2758 const wxChar* className,
2759 int setThisOwn) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2763
2764 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2765 }
2766
2767
2768 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2769 // Ensures that the proxy object is of the specified (or derived) type. If
2770 // not able to perform the conversion then a Python exception is set and the
2771 // error should be handled properly in the caller. Returns True on success.
2772 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2773 const wxChar* className) {
2774
2775 swig_type_info* swigType = wxPyFindSwigType(className);
2776 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2777
2778 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2779 }
2780
2781
2782
2783 // Make a SWIGified pointer object suitable for a .this attribute
2784 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2785
2786 PyObject* robj = NULL;
2787
2788 swig_type_info* swigType = wxPyFindSwigType(className);
2789 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2790
2791 robj = PySwigObject_New(ptr, swigType, 0);
2792 return robj;
2793 }
2794
2795
2796 // Python's PyInstance_Check does not return True for instances of new-style
2797 // classes. This should get close enough for both new and old classes but I
2798 // should re-evaluate the need for doing instance checks...
2799 bool wxPyInstance_Check(PyObject* obj) {
2800 return PyObject_HasAttrString(obj, "__class__") != 0;
2801 }
2802
2803
2804 // This one checks if the object is an instance of a SWIG proxy class (it has
2805 // a .this attribute, and the .this attribute is a PySwigObject.)
2806 bool wxPySwigInstance_Check(PyObject* obj) {
2807 static PyObject* this_str = NULL;
2808 if (this_str == NULL)
2809 this_str = PyString_FromString("this");
2810
2811 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2812 if (this_attr) {
2813 bool retval = (PySwigObject_Check(this_attr) != 0);
2814 Py_DECREF(this_attr);
2815 return retval;
2816 }
2817
2818 PyErr_Clear();
2819 return false;
2820 }
2821
2822
2823 // Export a C API in a struct. Other modules will be able to load this from
2824 // the wx._core_ module and will then have safe access to these functions,
2825 // even if they are located in another shared library.
2826 static wxPyCoreAPI API = {
2827
2828 wxPyCheckSwigType,
2829 wxPyConstructObject,
2830 wxPyConvertSwigPtr,
2831 wxPyMakeSwigPtr,
2832
2833 wxPyBeginAllowThreads,
2834 wxPyEndAllowThreads,
2835 wxPyBeginBlockThreads,
2836 wxPyEndBlockThreads,
2837
2838 wxPy_ConvertList,
2839
2840 wxString_in_helper,
2841 Py2wxString,
2842 wx2PyString,
2843
2844 byte_LIST_helper,
2845 int_LIST_helper,
2846 long_LIST_helper,
2847 string_LIST_helper,
2848 wxPoint_LIST_helper,
2849 wxBitmap_LIST_helper,
2850 wxString_LIST_helper,
2851 wxAcceleratorEntry_LIST_helper,
2852
2853 wxSize_helper,
2854 wxPoint_helper,
2855 wxRealPoint_helper,
2856 wxRect_helper,
2857 wxColour_helper,
2858 wxPoint2D_helper,
2859
2860 wxPySimple_typecheck,
2861 wxColour_typecheck,
2862
2863 wxPyCBH_setCallbackInfo,
2864 wxPyCBH_findCallback,
2865 wxPyCBH_callCallback,
2866 wxPyCBH_callCallbackObj,
2867 wxPyCBH_delete,
2868
2869 wxPyMake_wxObject,
2870 wxPyMake_wxSizer,
2871 wxPyPtrTypeMap_Add,
2872 wxPy2int_seq_helper,
2873 wxPy4int_seq_helper,
2874 wxArrayString2PyList_helper,
2875 wxArrayInt2PyList_helper,
2876
2877 wxPyClientData_dtor,
2878 wxPyUserData_dtor,
2879 wxPyOORClientData_dtor,
2880
2881 wxPyCBInputStream_create,
2882 wxPyCBInputStream_copy,
2883
2884 wxPyInstance_Check,
2885 wxPySwigInstance_Check,
2886
2887 wxPyCheckForApp
2888
2889 };
2890
2891 #endif
2892
2893
2894 #if !WXWIN_COMPATIBILITY_2_4
2895 #define wxHIDE_READONLY 0
2896 #endif
2897
2898
2899 #define SWIG_From_long PyInt_FromLong
2900
2901
2902 SWIGINTERNINLINE PyObject *
2903 SWIG_From_int (int value)
2904 {
2905 return SWIG_From_long (value);
2906 }
2907
2908 static const wxString wxPyEmptyString(wxEmptyString);
2909 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2910 return self->GetClassInfo()->GetClassName();
2911 }
2912 SWIGINTERN void wxObject_Destroy(wxObject *self){
2913 delete self;
2914 }
2915
2916 #ifndef __WXMAC__
2917 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2918 #endif
2919
2920
2921 #include <limits.h>
2922 #ifndef LLONG_MIN
2923 # define LLONG_MIN LONG_LONG_MIN
2924 #endif
2925 #ifndef LLONG_MAX
2926 # define LLONG_MAX LONG_LONG_MAX
2927 #endif
2928 #ifndef ULLONG_MAX
2929 # define ULLONG_MAX ULONG_LONG_MAX
2930 #endif
2931
2932
2933 SWIGINTERN int
2934 SWIG_AsVal_long (PyObject* obj, long* val)
2935 {
2936 if (PyNumber_Check(obj)) {
2937 if (val) *val = PyInt_AsLong(obj);
2938 return SWIG_OK;
2939 }
2940 return SWIG_TypeError;
2941 }
2942
2943
2944 SWIGINTERN int
2945 SWIG_AsVal_int (PyObject * obj, int *val)
2946 {
2947 long v;
2948 int res = SWIG_AsVal_long (obj, &v);
2949 if (SWIG_IsOK(res)) {
2950 if ((v < INT_MIN || v > INT_MAX)) {
2951 return SWIG_OverflowError;
2952 } else {
2953 if (val) *val = static_cast< int >(v);
2954 }
2955 }
2956 return res;
2957 }
2958
2959 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2960 wxSize temp, *obj = &temp;
2961 if ( other == Py_None ) return false;
2962 if ( ! wxSize_helper(other, &obj) ) {
2963 PyErr_Clear();
2964 return false;
2965 }
2966 return self->operator==(*obj);
2967 }
2968 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2969 wxSize temp, *obj = &temp;
2970 if ( other == Py_None ) return true;
2971 if ( ! wxSize_helper(other, &obj)) {
2972 PyErr_Clear();
2973 return true;
2974 }
2975 return self->operator!=(*obj);
2976 }
2977 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2979 PyObject* tup = PyTuple_New(2);
2980 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2981 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2982 wxPyEndBlockThreads(blocked);
2983 return tup;
2984 }
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 #define SWIG_From_double PyFloat_FromDouble
2998
2999 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3000 wxRealPoint temp, *obj = &temp;
3001 if ( other == Py_None ) return false;
3002 if ( ! wxRealPoint_helper(other, &obj) ) {
3003 PyErr_Clear();
3004 return false;
3005 }
3006 return self->operator==(*obj);
3007 }
3008 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3009 wxRealPoint temp, *obj = &temp;
3010 if ( other == Py_None ) return true;
3011 if ( ! wxRealPoint_helper(other, &obj)) {
3012 PyErr_Clear();
3013 return true;
3014 }
3015 return self->operator!=(*obj);
3016 }
3017 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3018 self->x = x;
3019 self->y = y;
3020 }
3021 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3026 wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3030 wxPoint temp, *obj = &temp;
3031 if ( other == Py_None ) return false;
3032 if ( ! wxPoint_helper(other, &obj) ) {
3033 PyErr_Clear();
3034 return false;
3035 }
3036 return self->operator==(*obj);
3037 }
3038 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3039 wxPoint temp, *obj = &temp;
3040 if ( other == Py_None ) return true;
3041 if ( ! wxPoint_helper(other, &obj)) {
3042 PyErr_Clear();
3043 return true;
3044 }
3045 return self->operator!=(*obj);
3046 }
3047 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3048 self->x = x;
3049 self->y = y;
3050 }
3051 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3052 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 PyObject* tup = PyTuple_New(2);
3054 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3055 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3056 wxPyEndBlockThreads(blocked);
3057 return tup;
3058 }
3059 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3060 wxRect temp, *obj = &temp;
3061 if ( other == Py_None ) return false;
3062 if ( ! wxRect_helper(other, &obj) ) {
3063 PyErr_Clear();
3064 return false;
3065 }
3066 return self->operator==(*obj);
3067 }
3068 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3069 wxRect temp, *obj = &temp;
3070 if ( other == Py_None ) return true;
3071 if ( ! wxRect_helper(other, &obj)) {
3072 PyErr_Clear();
3073 return true;
3074 }
3075 return self->operator!=(*obj);
3076 }
3077 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3078 self->x = x;
3079 self->y = y;
3080 self->width = width;
3081 self->height = height;
3082 }
3083 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3085 PyObject* tup = PyTuple_New(4);
3086 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3087 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3088 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3089 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3090 wxPyEndBlockThreads(blocked);
3091 return tup;
3092 }
3093
3094 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3095 wxRegion reg1(*r1);
3096 wxRegion reg2(*r2);
3097 wxRect dest(0,0,0,0);
3098 PyObject* obj;
3099
3100 reg1.Intersect(reg2);
3101 dest = reg1.GetBox();
3102
3103 if (dest != wxRect(0,0,0,0)) {
3104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3105 wxRect* newRect = new wxRect(dest);
3106 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3107 wxPyEndBlockThreads(blocked);
3108 return obj;
3109 }
3110 Py_INCREF(Py_None);
3111 return Py_None;
3112 }
3113
3114 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3115 wxPoint2D temp, *obj = &temp;
3116 if ( other == Py_None ) return false;
3117 if ( ! wxPoint2D_helper(other, &obj) ) {
3118 PyErr_Clear();
3119 return false;
3120 }
3121 return self->operator==(*obj);
3122 }
3123 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3124 wxPoint2D temp, *obj = &temp;
3125 if ( other == Py_None ) return true;
3126 if ( ! wxPoint2D_helper(other, &obj)) {
3127 PyErr_Clear();
3128 return true;
3129 }
3130 return self->operator!=(*obj);
3131 }
3132 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3133 self->m_x = x;
3134 self->m_y = y;
3135 }
3136 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 PyObject* tup = PyTuple_New(2);
3139 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3140 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3141 wxPyEndBlockThreads(blocked);
3142 return tup;
3143 }
3144
3145 #include "wx/wxPython/pyistream.h"
3146
3147 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3148 wxInputStream* wxis = wxPyCBInputStream::create(p);
3149 if (wxis)
3150 return new wxPyInputStream(wxis);
3151 else
3152 return NULL;
3153 }
3154
3155 SWIGINTERN swig_type_info*
3156 SWIG_pchar_descriptor()
3157 {
3158 static int init = 0;
3159 static swig_type_info* info = 0;
3160 if (!init) {
3161 info = SWIG_TypeQuery("_p_char");
3162 init = 1;
3163 }
3164 return info;
3165 }
3166
3167
3168 SWIGINTERNINLINE PyObject *
3169 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3170 {
3171 if (carray) {
3172 if (size > INT_MAX) {
3173 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3174 return pchar_descriptor ?
3175 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3176 } else {
3177 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3178 }
3179 } else {
3180 return SWIG_Py_Void();
3181 }
3182 }
3183
3184
3185 SWIGINTERNINLINE PyObject *
3186 SWIG_From_char (char c)
3187 {
3188 return SWIG_FromCharPtrAndSize(&c,1);
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject*
3193 SWIG_From_unsigned_SS_long (unsigned long value)
3194 {
3195 return (value > LONG_MAX) ?
3196 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3197 }
3198
3199
3200 SWIGINTERNINLINE PyObject *
3201 SWIG_From_size_t (size_t value)
3202 {
3203 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3204 }
3205
3206
3207 SWIGINTERN int
3208 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3209 {
3210 if (PyString_Check(obj)) {
3211 char *cstr; int len;
3212 PyString_AsStringAndSize(obj, &cstr, &len);
3213 if (cptr) {
3214 if (alloc) {
3215 /*
3216 In python the user should not be able to modify the inner
3217 string representation. To warranty that, if you define
3218 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3219 buffer is always returned.
3220
3221 The default behavior is just to return the pointer value,
3222 so, be careful.
3223 */
3224 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3225 if (*alloc != SWIG_OLDOBJ)
3226 #else
3227 if (*alloc == SWIG_NEWOBJ)
3228 #endif
3229 {
3230 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3231 *alloc = SWIG_NEWOBJ;
3232 }
3233 else {
3234 *cptr = cstr;
3235 *alloc = SWIG_OLDOBJ;
3236 }
3237 } else {
3238 *cptr = PyString_AsString(obj);
3239 }
3240 }
3241 if (psize) *psize = len + 1;
3242 return SWIG_OK;
3243 } else {
3244 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3245 if (pchar_descriptor) {
3246 void* vptr = 0;
3247 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3248 if (cptr) *cptr = (char *) vptr;
3249 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3250 if (alloc) *alloc = SWIG_OLDOBJ;
3251 return SWIG_OK;
3252 }
3253 }
3254 }
3255 return SWIG_TypeError;
3256 }
3257
3258
3259 SWIGINTERN int
3260 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3261 {
3262 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3263 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3264 if (SWIG_IsOK(res)) {
3265 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3266 if (csize <= size) {
3267 if (val) {
3268 if (csize) memcpy(val, cptr, csize*sizeof(char));
3269 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3270 }
3271 if (alloc == SWIG_NEWOBJ) {
3272 delete[] cptr;
3273 res = SWIG_DelNewMask(res);
3274 }
3275 return res;
3276 }
3277 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsVal_char (PyObject * obj, char *val)
3285 {
3286 int res = SWIG_AsCharArray(obj, val, 1);
3287 if (!SWIG_IsOK(res)) {
3288 long v;
3289 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3290 if (SWIG_IsOK(res)) {
3291 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3292 if (val) *val = static_cast< char >(v);
3293 } else {
3294 res = SWIG_OverflowError;
3295 }
3296 }
3297 }
3298 return res;
3299 }
3300
3301 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3302 // We use only strings for the streams, not unicode
3303 PyObject* str = PyObject_Str(obj);
3304 if (! str) {
3305 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3306 return;
3307 }
3308 self->Write(PyString_AS_STRING(str),
3309 PyString_GET_SIZE(str));
3310 Py_DECREF(str);
3311 }
3312
3313 #include "wx/wxPython/pyistream.h"
3314
3315
3316 class wxPyFileSystemHandler : public wxFileSystemHandler
3317 {
3318 public:
3319 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3320
3321 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3322 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3323 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3324 DEC_PYCALLBACK_STRING__pure(FindNext);
3325
3326 wxString GetProtocol(const wxString& location) {
3327 return wxFileSystemHandler::GetProtocol(location);
3328 }
3329
3330 wxString GetLeftLocation(const wxString& location) {
3331 return wxFileSystemHandler::GetLeftLocation(location);
3332 }
3333
3334 wxString GetAnchor(const wxString& location) {
3335 return wxFileSystemHandler::GetAnchor(location);
3336 }
3337
3338 wxString GetRightLocation(const wxString& location) {
3339 return wxFileSystemHandler::GetRightLocation(location);
3340 }
3341
3342 wxString GetMimeTypeFromExt(const wxString& location) {
3343 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3344 }
3345
3346 PYPRIVATE;
3347 };
3348
3349
3350 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3351 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3352 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3353 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3354
3355
3356 SWIGINTERN int
3357 SWIG_AsVal_bool (PyObject *obj, bool *val)
3358 {
3359 if (obj == Py_True) {
3360 if (val) *val = true;
3361 return SWIG_OK;
3362 } else if (obj == Py_False) {
3363 if (val) *val = false;
3364 return SWIG_OK;
3365 } else {
3366 long v = 0;
3367 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3368 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3369 return res;
3370 }
3371 }
3372
3373 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3374 wxFileName fname = wxFileSystem::URLToFileName(url);
3375 return fname.GetFullPath();
3376 }
3377
3378 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3379 wxImage& image,
3380 long type) {
3381 wxMemoryFSHandler::AddFile(filename, image, type);
3382 }
3383
3384 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3385 const wxBitmap& bitmap,
3386 long type) {
3387 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3388 }
3389
3390 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3391 PyObject* data) {
3392 if (! PyString_Check(data)) {
3393 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3394 "Expected string object"));
3395 return;
3396 }
3397
3398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3399 void* ptr = (void*)PyString_AsString(data);
3400 size_t size = PyString_Size(data);
3401 wxPyEndBlockThreads(blocked);
3402
3403 wxMemoryFSHandler::AddFile(filename, ptr, size);
3404 }
3405
3406
3407 #include "wx/wxPython/pyistream.h"
3408
3409
3410 SWIGINTERN int
3411 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3412 {
3413 long v = 0;
3414 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3415 return SWIG_TypeError;
3416 }
3417 else if (val)
3418 *val = (unsigned long)v;
3419 return SWIG_OK;
3420 }
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3425 {
3426 unsigned long v;
3427 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3428 if (SWIG_IsOK(res)) {
3429 if ((v > UCHAR_MAX)) {
3430 return SWIG_OverflowError;
3431 } else {
3432 if (val) *val = static_cast< unsigned char >(v);
3433 }
3434 }
3435 return res;
3436 }
3437
3438
3439 SWIGINTERNINLINE PyObject *
3440 SWIG_From_unsigned_SS_char (unsigned char value)
3441 {
3442 return SWIG_From_unsigned_SS_long (value);
3443 }
3444
3445 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3446 wxImageHistogramEntry e = (*self)[key];
3447 return e.value;
3448 }
3449 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3450 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3451 wxImageHistogramEntry e = (*self)[key];
3452 return e.value;
3453 }
3454 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3455 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3456 colour.Green(),
3457 colour.Blue());
3458 wxImageHistogramEntry e = (*self)[key];
3459 return e.value;
3460 }
3461
3462 typedef unsigned char* buffer;
3463
3464
3465 // Pull the nested class out to the top level for SWIG's sake
3466 #define wxImage_RGBValue wxImage::RGBValue
3467 #define wxImage_HSVValue wxImage::HSVValue
3468
3469 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3470 if (width > 0 && height > 0)
3471 return new wxImage(width, height, clear);
3472 else
3473 return new wxImage;
3474 }
3475 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3476 return new wxImage(bitmap.ConvertToImage());
3477 }
3478 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3479 if (DATASIZE != width*height*3) {
3480 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3481 return NULL;
3482 }
3483
3484 // Copy the source data so the wxImage can clean it up later
3485 buffer copy = (buffer)malloc(DATASIZE);
3486 if (copy == NULL) {
3487 wxPyBLOCK_THREADS(PyErr_NoMemory());
3488 return NULL;
3489 }
3490 memcpy(copy, data, DATASIZE);
3491 return new wxImage(width, height, copy, false);
3492 }
3493 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3494 if (DATASIZE != width*height*3) {
3495 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3496 return NULL;
3497 }
3498 if (ALPHASIZE != width*height) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3500 return NULL;
3501 }
3502
3503 // Copy the source data so the wxImage can clean it up later
3504 buffer dcopy = (buffer)malloc(DATASIZE);
3505 if (dcopy == NULL) {
3506 wxPyBLOCK_THREADS(PyErr_NoMemory());
3507 return NULL;
3508 }
3509 memcpy(dcopy, data, DATASIZE);
3510
3511 buffer acopy = (buffer)malloc(ALPHASIZE);
3512 if (acopy == NULL) {
3513 wxPyBLOCK_THREADS(PyErr_NoMemory());
3514 return NULL;
3515 }
3516 memcpy(acopy, alpha, ALPHASIZE);
3517
3518 return new wxImage(width, height, dcopy, acopy, false);
3519 }
3520 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3521 wxSize size(self->GetWidth(), self->GetHeight());
3522 return size;
3523 }
3524 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3525 buffer data = self->GetData();
3526 int len = self->GetWidth() * self->GetHeight() * 3;
3527 PyObject* rv;
3528 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3529 return rv;
3530 }
3531 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3532 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3533 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3534 return;
3535 }
3536 buffer copy = (buffer)malloc(DATASIZE);
3537 if (copy == NULL) {
3538 wxPyBLOCK_THREADS(PyErr_NoMemory());
3539 return;
3540 }
3541 memcpy(copy, data, DATASIZE);
3542 self->SetData(copy, false);
3543 // wxImage takes ownership of copy...
3544 }
3545 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 self->SetData(data, true);
3558 }
3559 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3560 buffer data = self->GetAlpha();
3561 if (! data) {
3562 RETURN_NONE();
3563 } else {
3564 int len = self->GetWidth() * self->GetHeight();
3565 PyObject* rv;
3566 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3567 return rv;
3568 }
3569 }
3570 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3571 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3572 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3573 return;
3574 }
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581 self->SetAlpha(acopy, false);
3582 // wxImage takes ownership of acopy...
3583 }
3584 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3585 buffer data = self->GetAlpha();
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3589 return rv;
3590 }
3591 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 self->SetAlpha(alpha, true);
3597 }
3598 SWIGINTERN PyObject *wxImage_GetHandlers(){
3599 wxList& list = wxImage::GetHandlers();
3600 return wxPy_ConvertList(&list);
3601 }
3602 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3603 wxBitmap bitmap(*self, depth);
3604 return bitmap;
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3607 wxImage mono = self->ConvertToMono( red, green, blue );
3608 wxBitmap bitmap( mono, 1 );
3609 return bitmap;
3610 }
3611 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3612 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3614 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3618 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3619 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3620 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3621 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3622 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3623 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3624 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3625 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3626
3627 #include <wx/quantize.h>
3628
3629 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3630 return wxQuantize::Quantize(src, dest,
3631 //NULL, // palette
3632 desiredNoColours,
3633 NULL, // eightBitData
3634 flags);
3635 }
3636 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3637 if (PyCallable_Check(func)) {
3638 self->Connect(id, lastId, eventType,
3639 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3640 new wxPyCallback(func));
3641 }
3642 else if (func == Py_None) {
3643 self->Disconnect(id, lastId, eventType,
3644 (wxObjectEventFunction)
3645 &wxPyCallback::EventThunker);
3646 }
3647 else {
3648 wxPyBLOCK_THREADS(
3649 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3650 }
3651 }
3652 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3653 return self->Disconnect(id, lastId, eventType,
3654 (wxObjectEventFunction)
3655 &wxPyCallback::EventThunker);
3656 }
3657 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3658 if (_self && _self != Py_None) {
3659 self->SetClientObject(new wxPyOORClientData(_self, incref));
3660 }
3661 else {
3662 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3663 if (data) {
3664 self->SetClientObject(NULL); // This will delete it too
3665 }
3666 }
3667 }
3668
3669 #if ! wxUSE_HOTKEY
3670 #define wxEVT_HOTKEY -9999
3671 #endif
3672
3673 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3674 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3675 if (data) {
3676 Py_INCREF(data->m_obj);
3677 return data->m_obj;
3678 } else {
3679 Py_INCREF(Py_None);
3680 return Py_None;
3681 }
3682 }
3683 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3684 wxPyClientData* data = new wxPyClientData(clientData);
3685 self->SetClientObject(data);
3686 }
3687 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3688 #if wxUSE_UNICODE
3689 return self->GetUnicodeKey();
3690 #else
3691 return 0;
3692 #endif
3693 }
3694 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3695 #if wxUSE_UNICODE
3696 self->m_uniChar = uniChar;
3697 #endif
3698 }
3699
3700 SWIGINTERNINLINE PyObject *
3701 SWIG_From_unsigned_SS_int (unsigned int value)
3702 {
3703 return SWIG_From_unsigned_SS_long (value);
3704 }
3705
3706
3707 SWIGINTERN int
3708 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3709 {
3710 unsigned long v;
3711 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3712 if (SWIG_IsOK(res)) {
3713 if ((v > UINT_MAX)) {
3714 return SWIG_OverflowError;
3715 } else {
3716 if (val) *val = static_cast< unsigned int >(v);
3717 }
3718 }
3719 return res;
3720 }
3721
3722 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3723 self->m_size = size;
3724 }
3725 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3726 int count = self->GetNumberOfFiles();
3727 wxString* files = self->GetFiles();
3728 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3729 PyObject* list = PyList_New(count);
3730
3731 if (!list) {
3732 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3733 wxPyEndBlockThreads(blocked);
3734 return NULL;
3735 }
3736
3737 for (int i=0; i<count; i++) {
3738 PyList_SetItem(list, i, wx2PyString(files[i]));
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 return list;
3742 }
3743
3744
3745 SWIGINTERN wxPyApp *new_wxPyApp(){
3746 wxPythonApp = new wxPyApp();
3747 return wxPythonApp;
3748 }
3749 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3750
3751 void wxApp_CleanUp() {
3752 __wxPyCleanup();
3753 }
3754
3755
3756 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3757
3758
3759
3760
3761
3762 SWIGINTERNINLINE PyObject *
3763 SWIG_FromCharPtr(const char *cptr)
3764 {
3765 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3766 }
3767
3768
3769 #if 0 // #ifdef __WXMAC__
3770
3771 // A dummy class that raises an exception if used...
3772 class wxEventLoop
3773 {
3774 public:
3775 wxEventLoop() { wxPyRaiseNotImplemented(); }
3776 int Run() { return 0; }
3777 void Exit(int rc = 0) {}
3778 bool Pending() const { return false; }
3779 bool Dispatch() { return false; }
3780 bool IsRunning() const { return false; }
3781 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3782 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3783 };
3784
3785 #else
3786
3787 #include <wx/evtloop.h>
3788
3789 #endif
3790
3791
3792
3793 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3794 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3795 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3796 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3797 wxWindowList& list = self->GetChildren();
3798 return wxPy_ConvertList(&list);
3799 }
3800 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3801 #if wxUSE_HOTKEY
3802 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3803 #else
3804 return false;
3805 #endif
3806 }
3807 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3808
3809
3810
3811 return false;
3812
3813 }
3814 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3815 return wxPyGetWinHandle(self);
3816 }
3817 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3818 self->AssociateHandle((WXWidget)handle);
3819 }
3820 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3821
3822 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3823 return wxWindow::FindWindowById(id, parent);
3824 }
3825
3826 wxWindow* wxFindWindowByName( const wxString& name,
3827 const wxWindow *parent = NULL ) {
3828 return wxWindow::FindWindowByName(name, parent);
3829 }
3830
3831 wxWindow* wxFindWindowByLabel( const wxString& label,
3832 const wxWindow *parent = NULL ) {
3833 return wxWindow::FindWindowByLabel(label, parent);
3834 }
3835
3836
3837 #ifdef __WXMSW__
3838 #include <wx/msw/private.h> // to get wxGetWindowId
3839 #endif
3840
3841
3842 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3843 #ifdef __WXMSW__
3844 WXHWND hWnd = (WXHWND)_hWnd;
3845 long id = wxGetWindowId(hWnd);
3846 wxWindow* win = new wxWindow;
3847 if (parent)
3848 parent->AddChild(win);
3849 win->SetEventHandler(win);
3850 win->SetHWND(hWnd);
3851 win->SetId(id);
3852 win->SubclassWin(hWnd);
3853 win->AdoptAttributesFromHWND();
3854 win->SetupColours();
3855 return win;
3856 #else
3857 wxPyRaiseNotImplemented();
3858 return NULL;
3859 #endif
3860 }
3861
3862
3863 PyObject* GetTopLevelWindows() {
3864 return wxPy_ConvertList(&wxTopLevelWindows);
3865 }
3866
3867
3868 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3869 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3870 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3871
3872 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3873
3874
3875 SWIGINTERNINLINE int
3876 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3877 {
3878 unsigned long v;
3879 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3880 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3881 return res;
3882 }
3883
3884 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3885 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3886 wxMenuItemList& list = self->GetMenuItems();
3887 return wxPy_ConvertList(&list);
3888 }
3889 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3890 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3891 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3892 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3893 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3894 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3895 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3896 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3897 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3898 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3899 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3900 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3901 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3902 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3903 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3904 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3905 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3906 static const wxString wxPyControlNameStr(wxControlNameStr);
3907 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3908 if (clientData) {
3909 wxPyClientData* data = new wxPyClientData(clientData);
3910 return self->Append(item, data);
3911 } else
3912 return self->Append(item);
3913 }
3914 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3915 if (clientData) {
3916 wxPyClientData* data = new wxPyClientData(clientData);
3917 return self->Insert(item, pos, data);
3918 } else
3919 return self->Insert(item, pos);
3920 }
3921 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3922 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3923 if (data) {
3924 Py_INCREF(data->m_obj);
3925 return data->m_obj;
3926 } else {
3927 Py_INCREF(Py_None);
3928 return Py_None;
3929 }
3930 }
3931 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3932 wxPyClientData* data = new wxPyClientData(clientData);
3933 self->SetClientObject(n, data);
3934 }
3935
3936
3937 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3938 wxPyUserData* data = NULL;
3939 if ( userData ) {
3940 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3941 data = new wxPyUserData(userData);
3942 wxPyEndBlockThreads(blocked);
3943 }
3944 return new wxSizerItem(window, proportion, flag, border, data);
3945 }
3946 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3947 wxPyUserData* data = NULL;
3948 if ( userData ) {
3949 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3950 data = new wxPyUserData(userData);
3951 wxPyEndBlockThreads(blocked);
3952 }
3953 return new wxSizerItem(width, height, proportion, flag, border, data);
3954 }
3955 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3956 wxPyUserData* data = NULL;
3957 if ( userData ) {
3958 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3959 data = new wxPyUserData(userData);
3960 wxPyEndBlockThreads(blocked);
3961 }
3962 return new wxSizerItem(sizer, proportion, flag, border, data);
3963 }
3964
3965 #include <float.h>
3966
3967
3968 SWIGINTERN int
3969 SWIG_AsVal_float (PyObject * obj, float *val)
3970 {
3971 double v;
3972 int res = SWIG_AsVal_double (obj, &v);
3973 if (SWIG_IsOK(res)) {
3974 if ((v < -FLT_MAX || v > FLT_MAX)) {
3975 return SWIG_OverflowError;
3976 } else {
3977 if (val) *val = static_cast< float >(v);
3978 }
3979 }
3980 return res;
3981 }
3982
3983
3984 SWIGINTERNINLINE PyObject *
3985 SWIG_From_float (float value)
3986 {
3987 return SWIG_From_double (value);
3988 }
3989
3990 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3991 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3992 if (data) {
3993 Py_INCREF(data->m_obj);
3994 return data->m_obj;
3995 } else {
3996 Py_INCREF(Py_None);
3997 return Py_None;
3998 }
3999 }
4000 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4001 wxPyUserData* data = NULL;
4002 if ( userData ) {
4003 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4004 data = new wxPyUserData(userData);
4005 wxPyEndBlockThreads(blocked);
4006 }
4007 self->SetUserData(data);
4008 }
4009
4010 // Figure out the type of the sizer item
4011
4012 struct wxPySizerItemInfo {
4013 wxPySizerItemInfo()
4014 : window(NULL), sizer(NULL), gotSize(false),
4015 size(wxDefaultSize), gotPos(false), pos(-1)
4016 {}
4017
4018 wxWindow* window;
4019 wxSizer* sizer;
4020 bool gotSize;
4021 wxSize size;
4022 bool gotPos;
4023 int pos;
4024 };
4025
4026 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4027
4028 wxPySizerItemInfo info;
4029 wxSize size;
4030 wxSize* sizePtr = &size;
4031
4032 // Find out what the type of the item is
4033 // try wxWindow
4034 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4035 PyErr_Clear();
4036 info.window = NULL;
4037
4038 // try wxSizer
4039 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4040 PyErr_Clear();
4041 info.sizer = NULL;
4042
4043 // try wxSize or (w,h)
4044 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4045 info.size = *sizePtr;
4046 info.gotSize = true;
4047 }
4048
4049 // or a single int
4050 if (checkIdx && PyInt_Check(item)) {
4051 info.pos = PyInt_AsLong(item);
4052 info.gotPos = true;
4053 }
4054 }
4055 }
4056
4057 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4058 // no expected type, figure out what kind of error message to generate
4059 if ( !checkSize && !checkIdx )
4060 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4061 else if ( checkSize && !checkIdx )
4062 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4063 else if ( !checkSize && checkIdx)
4064 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4065 else
4066 // can this one happen?
4067 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4068 }
4069
4070 return info;
4071 }
4072
4073 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4074 if (!self->GetClientObject())
4075 self->SetClientObject(new wxPyOORClientData(_self));
4076 }
4077 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4078
4079 wxPyUserData* data = NULL;
4080 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4081 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4082 if ( userData && (info.window || info.sizer || info.gotSize) )
4083 data = new wxPyUserData(userData);
4084 if ( info.sizer )
4085 PyObject_SetAttrString(item,"thisown",Py_False);
4086 wxPyEndBlockThreads(blocked);
4087
4088 // Now call the real Add method if a valid item type was found
4089 if ( info.window )
4090 return self->Add(info.window, proportion, flag, border, data);
4091 else if ( info.sizer )
4092 return self->Add(info.sizer, proportion, flag, border, data);
4093 else if (info.gotSize)
4094 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4095 proportion, flag, border, data);
4096 else
4097 return NULL;
4098 }
4099 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4100
4101 wxPyUserData* data = NULL;
4102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4103 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4104 if ( userData && (info.window || info.sizer || info.gotSize) )
4105 data = new wxPyUserData(userData);
4106 if ( info.sizer )
4107 PyObject_SetAttrString(item,"thisown",Py_False);
4108 wxPyEndBlockThreads(blocked);
4109
4110 // Now call the real Insert method if a valid item type was found
4111 if ( info.window )
4112 return self->Insert(before, info.window, proportion, flag, border, data);
4113 else if ( info.sizer )
4114 return self->Insert(before, info.sizer, proportion, flag, border, data);
4115 else if (info.gotSize)
4116 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4117 proportion, flag, border, data);
4118 else
4119 return NULL;
4120 }
4121 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4122
4123 wxPyUserData* data = NULL;
4124 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4125 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4126 if ( userData && (info.window || info.sizer || info.gotSize) )
4127 data = new wxPyUserData(userData);
4128 if ( info.sizer )
4129 PyObject_SetAttrString(item,"thisown",Py_False);
4130 wxPyEndBlockThreads(blocked);
4131
4132 // Now call the real Prepend method if a valid item type was found
4133 if ( info.window )
4134 return self->Prepend(info.window, proportion, flag, border, data);
4135 else if ( info.sizer )
4136 return self->Prepend(info.sizer, proportion, flag, border, data);
4137 else if (info.gotSize)
4138 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4139 proportion, flag, border, data);
4140 else
4141 return NULL;
4142 }
4143 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4144 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4145 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4146 wxPyEndBlockThreads(blocked);
4147 if ( info.window )
4148 return self->Remove(info.window);
4149 else if ( info.sizer )
4150 return self->Remove(info.sizer);
4151 else if ( info.gotPos )
4152 return self->Remove(info.pos);
4153 else
4154 return false;
4155 }
4156 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4157 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4158 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4159 wxPyEndBlockThreads(blocked);
4160 if ( info.window )
4161 return self->Detach(info.window);
4162 else if ( info.sizer )
4163 return self->Detach(info.sizer);
4164 else if ( info.gotPos )
4165 return self->Detach(info.pos);
4166 else
4167 return false;
4168 }
4169 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4172 wxPyEndBlockThreads(blocked);
4173 if ( info.window )
4174 return self->GetItem(info.window);
4175 else if ( info.sizer )
4176 return self->GetItem(info.sizer);
4177 else if ( info.gotPos )
4178 return self->GetItem(info.pos);
4179 else
4180 return NULL;
4181 }
4182 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4183 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4184 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4185 wxPyEndBlockThreads(blocked);
4186 if ( info.window )
4187 self->SetItemMinSize(info.window, size);
4188 else if ( info.sizer )
4189 self->SetItemMinSize(info.sizer, size);
4190 else if ( info.gotPos )
4191 self->SetItemMinSize(info.pos, size);
4192 }
4193 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4194 wxSizerItemList& list = self->GetChildren();
4195 return wxPy_ConvertList(&list);
4196 }
4197 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4199 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4200 wxPyEndBlockThreads(blocked);
4201 if ( info.window )
4202 return self->Show(info.window, show, recursive);
4203 else if ( info.sizer )
4204 return self->Show(info.sizer, show, recursive);
4205 else if ( info.gotPos )
4206 return self->Show(info.pos, show);
4207 else
4208 return false;
4209 }
4210 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4211 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4212 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4213 wxPyEndBlockThreads(blocked);
4214 if ( info.window )
4215 return self->IsShown(info.window);
4216 else if ( info.sizer )
4217 return self->IsShown(info.sizer);
4218 else if ( info.gotPos )
4219 return self->IsShown(info.pos);
4220 else
4221 return false;
4222 }
4223
4224 // See pyclasses.h
4225 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4226 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4227 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4228
4229
4230
4231
4232 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4233 {
4234 if (source == Py_None) {
4235 **obj = wxGBPosition(-1,-1);
4236 return true;
4237 }
4238 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4239 }
4240
4241 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4242 {
4243 if (source == Py_None) {
4244 **obj = wxGBSpan(-1,-1);
4245 return true;
4246 }
4247 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4248 }
4249
4250
4251 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4252 wxGBPosition temp, *obj = &temp;
4253 if ( other == Py_None ) return false;
4254 if ( ! wxGBPosition_helper(other, &obj) ) {
4255 PyErr_Clear();
4256 return false;
4257 }
4258 return self->operator==(*obj);
4259 }
4260 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4261 wxGBPosition temp, *obj = &temp;
4262 if ( other == Py_None ) return true;
4263 if ( ! wxGBPosition_helper(other, &obj)) {
4264 PyErr_Clear();
4265 return true;
4266 }
4267 return self->operator!=(*obj);
4268 }
4269 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4270 self->SetRow(row);
4271 self->SetCol(col);
4272 }
4273 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4274 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4275 PyObject* tup = PyTuple_New(2);
4276 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4277 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4278 wxPyEndBlockThreads(blocked);
4279 return tup;
4280 }
4281 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4282 wxGBSpan temp, *obj = &temp;
4283 if ( other == Py_None ) return false;
4284 if ( ! wxGBSpan_helper(other, &obj) ) {
4285 PyErr_Clear();
4286 return false;
4287 }
4288 return self->operator==(*obj);
4289 }
4290 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4291 wxGBSpan temp, *obj = &temp;
4292 if ( other == Py_None ) return true;
4293 if ( ! wxGBSpan_helper(other, &obj)) {
4294 PyErr_Clear();
4295 return true;
4296 }
4297 return self->operator!=(*obj);
4298 }
4299 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4300 self->SetRowspan(rowspan);
4301 self->SetColspan(colspan);
4302 }
4303 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4305 PyObject* tup = PyTuple_New(2);
4306 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4307 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4308 wxPyEndBlockThreads(blocked);
4309 return tup;
4310 }
4311 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4312 wxPyUserData* data = NULL;
4313 if ( userData ) {
4314 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4315 data = new wxPyUserData(userData);
4316 wxPyEndBlockThreads(blocked);
4317 }
4318 return new wxGBSizerItem(window, pos, span, flag, border, data);
4319 }
4320 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,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(sizer, pos, span, flag, border, data);
4328 }
4329 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,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(width, height, pos, span, flag, border, data);
4337 }
4338 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4339 int row, col;
4340 self->GetEndPos(row, col);
4341 return wxGBPosition(row, col);
4342 }
4343 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4344
4345 wxPyUserData* data = NULL;
4346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4347 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4348 if ( userData && (info.window || info.sizer || info.gotSize) )
4349 data = new wxPyUserData(userData);
4350 if ( info.sizer )
4351 PyObject_SetAttrString(item,"thisown",Py_False);
4352 wxPyEndBlockThreads(blocked);
4353
4354 // Now call the real Add method if a valid item type was found
4355 if ( info.window )
4356 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4357 else if ( info.sizer )
4358 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4359 else if (info.gotSize)
4360 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4361 pos, span, flag, border, data);
4362 return NULL;
4363 }
4364
4365
4366 #ifdef __cplusplus
4367 extern "C" {
4368 #endif
4369 SWIGINTERN int EmptyString_set(PyObject *) {
4370 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4371 return 1;
4372 }
4373
4374
4375 SWIGINTERN PyObject *EmptyString_get(void) {
4376 PyObject *pyobj = 0;
4377
4378 {
4379 #if wxUSE_UNICODE
4380 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4381 #else
4382 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4383 #endif
4384 }
4385 return pyobj;
4386 }
4387
4388
4389 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4390 PyObject *resultobj = 0;
4391 wxObject *arg1 = (wxObject *) 0 ;
4392 wxString result;
4393 void *argp1 = 0 ;
4394 int res1 = 0 ;
4395 PyObject *swig_obj[1] ;
4396
4397 if (!args) SWIG_fail;
4398 swig_obj[0] = args;
4399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4400 if (!SWIG_IsOK(res1)) {
4401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4402 }
4403 arg1 = reinterpret_cast< wxObject * >(argp1);
4404 {
4405 PyThreadState* __tstate = wxPyBeginAllowThreads();
4406 result = wxObject_GetClassName(arg1);
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 {
4411 #if wxUSE_UNICODE
4412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4413 #else
4414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4415 #endif
4416 }
4417 return resultobj;
4418 fail:
4419 return NULL;
4420 }
4421
4422
4423 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4424 PyObject *resultobj = 0;
4425 wxObject *arg1 = (wxObject *) 0 ;
4426 void *argp1 = 0 ;
4427 int res1 = 0 ;
4428 PyObject *swig_obj[1] ;
4429
4430 if (!args) SWIG_fail;
4431 swig_obj[0] = args;
4432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4433 if (!SWIG_IsOK(res1)) {
4434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4435 }
4436 arg1 = reinterpret_cast< wxObject * >(argp1);
4437 {
4438 PyThreadState* __tstate = wxPyBeginAllowThreads();
4439 wxObject_Destroy(arg1);
4440 wxPyEndAllowThreads(__tstate);
4441 if (PyErr_Occurred()) SWIG_fail;
4442 }
4443 resultobj = SWIG_Py_Void();
4444 return resultobj;
4445 fail:
4446 return NULL;
4447 }
4448
4449
4450 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4451 PyObject *obj;
4452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4453 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4454 return SWIG_Py_Void();
4455 }
4456
4457 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458 PyObject *resultobj = 0;
4459 wxSize *arg1 = (wxSize *) 0 ;
4460 int arg2 ;
4461 void *argp1 = 0 ;
4462 int res1 = 0 ;
4463 int val2 ;
4464 int ecode2 = 0 ;
4465 PyObject *swig_obj[2] ;
4466
4467 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4469 if (!SWIG_IsOK(res1)) {
4470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4471 }
4472 arg1 = reinterpret_cast< wxSize * >(argp1);
4473 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4474 if (!SWIG_IsOK(ecode2)) {
4475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4476 }
4477 arg2 = static_cast< int >(val2);
4478 if (arg1) (arg1)->x = arg2;
4479
4480 resultobj = SWIG_Py_Void();
4481 return resultobj;
4482 fail:
4483 return NULL;
4484 }
4485
4486
4487 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4488 PyObject *resultobj = 0;
4489 wxSize *arg1 = (wxSize *) 0 ;
4490 int result;
4491 void *argp1 = 0 ;
4492 int res1 = 0 ;
4493 PyObject *swig_obj[1] ;
4494
4495 if (!args) SWIG_fail;
4496 swig_obj[0] = args;
4497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4498 if (!SWIG_IsOK(res1)) {
4499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4500 }
4501 arg1 = reinterpret_cast< wxSize * >(argp1);
4502 result = (int) ((arg1)->x);
4503 resultobj = SWIG_From_int(static_cast< int >(result));
4504 return resultobj;
4505 fail:
4506 return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4511 PyObject *resultobj = 0;
4512 wxSize *arg1 = (wxSize *) 0 ;
4513 int arg2 ;
4514 void *argp1 = 0 ;
4515 int res1 = 0 ;
4516 int val2 ;
4517 int ecode2 = 0 ;
4518 PyObject *swig_obj[2] ;
4519
4520 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4527 if (!SWIG_IsOK(ecode2)) {
4528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4529 }
4530 arg2 = static_cast< int >(val2);
4531 if (arg1) (arg1)->y = arg2;
4532
4533 resultobj = SWIG_Py_Void();
4534 return resultobj;
4535 fail:
4536 return NULL;
4537 }
4538
4539
4540 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4541 PyObject *resultobj = 0;
4542 wxSize *arg1 = (wxSize *) 0 ;
4543 int result;
4544 void *argp1 = 0 ;
4545 int res1 = 0 ;
4546 PyObject *swig_obj[1] ;
4547
4548 if (!args) SWIG_fail;
4549 swig_obj[0] = args;
4550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4551 if (!SWIG_IsOK(res1)) {
4552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4553 }
4554 arg1 = reinterpret_cast< wxSize * >(argp1);
4555 result = (int) ((arg1)->y);
4556 resultobj = SWIG_From_int(static_cast< int >(result));
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4564 PyObject *resultobj = 0;
4565 int arg1 = (int) 0 ;
4566 int arg2 = (int) 0 ;
4567 wxSize *result = 0 ;
4568 int val1 ;
4569 int ecode1 = 0 ;
4570 int val2 ;
4571 int ecode2 = 0 ;
4572 PyObject * obj0 = 0 ;
4573 PyObject * obj1 = 0 ;
4574 char * kwnames[] = {
4575 (char *) "w",(char *) "h", NULL
4576 };
4577
4578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4579 if (obj0) {
4580 ecode1 = SWIG_AsVal_int(obj0, &val1);
4581 if (!SWIG_IsOK(ecode1)) {
4582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4583 }
4584 arg1 = static_cast< int >(val1);
4585 }
4586 if (obj1) {
4587 ecode2 = SWIG_AsVal_int(obj1, &val2);
4588 if (!SWIG_IsOK(ecode2)) {
4589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4590 }
4591 arg2 = static_cast< int >(val2);
4592 }
4593 {
4594 PyThreadState* __tstate = wxPyBeginAllowThreads();
4595 result = (wxSize *)new wxSize(arg1,arg2);
4596 wxPyEndAllowThreads(__tstate);
4597 if (PyErr_Occurred()) SWIG_fail;
4598 }
4599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4600 return resultobj;
4601 fail:
4602 return NULL;
4603 }
4604
4605
4606 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4607 PyObject *resultobj = 0;
4608 wxSize *arg1 = (wxSize *) 0 ;
4609 void *argp1 = 0 ;
4610 int res1 = 0 ;
4611 PyObject *swig_obj[1] ;
4612
4613 if (!args) SWIG_fail;
4614 swig_obj[0] = args;
4615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4616 if (!SWIG_IsOK(res1)) {
4617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4618 }
4619 arg1 = reinterpret_cast< wxSize * >(argp1);
4620 {
4621 PyThreadState* __tstate = wxPyBeginAllowThreads();
4622 delete arg1;
4623
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 resultobj = SWIG_Py_Void();
4628 return resultobj;
4629 fail:
4630 return NULL;
4631 }
4632
4633
4634 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4635 PyObject *resultobj = 0;
4636 wxSize *arg1 = (wxSize *) 0 ;
4637 PyObject *arg2 = (PyObject *) 0 ;
4638 bool result;
4639 void *argp1 = 0 ;
4640 int res1 = 0 ;
4641 PyObject * obj0 = 0 ;
4642 PyObject * obj1 = 0 ;
4643 char * kwnames[] = {
4644 (char *) "self",(char *) "other", NULL
4645 };
4646
4647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4649 if (!SWIG_IsOK(res1)) {
4650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4651 }
4652 arg1 = reinterpret_cast< wxSize * >(argp1);
4653 arg2 = obj1;
4654 {
4655 result = (bool)wxSize___eq__(arg1,arg2);
4656 if (PyErr_Occurred()) SWIG_fail;
4657 }
4658 {
4659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4660 }
4661 return resultobj;
4662 fail:
4663 return NULL;
4664 }
4665
4666
4667 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4668 PyObject *resultobj = 0;
4669 wxSize *arg1 = (wxSize *) 0 ;
4670 PyObject *arg2 = (PyObject *) 0 ;
4671 bool result;
4672 void *argp1 = 0 ;
4673 int res1 = 0 ;
4674 PyObject * obj0 = 0 ;
4675 PyObject * obj1 = 0 ;
4676 char * kwnames[] = {
4677 (char *) "self",(char *) "other", NULL
4678 };
4679
4680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4682 if (!SWIG_IsOK(res1)) {
4683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4684 }
4685 arg1 = reinterpret_cast< wxSize * >(argp1);
4686 arg2 = obj1;
4687 {
4688 result = (bool)wxSize___ne__(arg1,arg2);
4689 if (PyErr_Occurred()) SWIG_fail;
4690 }
4691 {
4692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4693 }
4694 return resultobj;
4695 fail:
4696 return NULL;
4697 }
4698
4699
4700 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4701 PyObject *resultobj = 0;
4702 wxSize *arg1 = (wxSize *) 0 ;
4703 wxSize *arg2 = 0 ;
4704 wxSize result;
4705 void *argp1 = 0 ;
4706 int res1 = 0 ;
4707 wxSize temp2 ;
4708 PyObject * obj0 = 0 ;
4709 PyObject * obj1 = 0 ;
4710 char * kwnames[] = {
4711 (char *) "self",(char *) "sz", NULL
4712 };
4713
4714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4716 if (!SWIG_IsOK(res1)) {
4717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4718 }
4719 arg1 = reinterpret_cast< wxSize * >(argp1);
4720 {
4721 arg2 = &temp2;
4722 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4723 }
4724 {
4725 PyThreadState* __tstate = wxPyBeginAllowThreads();
4726 result = (arg1)->operator +((wxSize const &)*arg2);
4727 wxPyEndAllowThreads(__tstate);
4728 if (PyErr_Occurred()) SWIG_fail;
4729 }
4730 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4731 return resultobj;
4732 fail:
4733 return NULL;
4734 }
4735
4736
4737 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4738 PyObject *resultobj = 0;
4739 wxSize *arg1 = (wxSize *) 0 ;
4740 wxSize *arg2 = 0 ;
4741 wxSize result;
4742 void *argp1 = 0 ;
4743 int res1 = 0 ;
4744 wxSize temp2 ;
4745 PyObject * obj0 = 0 ;
4746 PyObject * obj1 = 0 ;
4747 char * kwnames[] = {
4748 (char *) "self",(char *) "sz", NULL
4749 };
4750
4751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4753 if (!SWIG_IsOK(res1)) {
4754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4755 }
4756 arg1 = reinterpret_cast< wxSize * >(argp1);
4757 {
4758 arg2 = &temp2;
4759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4760 }
4761 {
4762 PyThreadState* __tstate = wxPyBeginAllowThreads();
4763 result = (arg1)->operator -((wxSize const &)*arg2);
4764 wxPyEndAllowThreads(__tstate);
4765 if (PyErr_Occurred()) SWIG_fail;
4766 }
4767 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4768 return resultobj;
4769 fail:
4770 return NULL;
4771 }
4772
4773
4774 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj = 0;
4776 wxSize *arg1 = (wxSize *) 0 ;
4777 wxSize *arg2 = 0 ;
4778 void *argp1 = 0 ;
4779 int res1 = 0 ;
4780 wxSize temp2 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char * kwnames[] = {
4784 (char *) "self",(char *) "sz", NULL
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4789 if (!SWIG_IsOK(res1)) {
4790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4791 }
4792 arg1 = reinterpret_cast< wxSize * >(argp1);
4793 {
4794 arg2 = &temp2;
4795 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4796 }
4797 {
4798 PyThreadState* __tstate = wxPyBeginAllowThreads();
4799 (arg1)->IncTo((wxSize const &)*arg2);
4800 wxPyEndAllowThreads(__tstate);
4801 if (PyErr_Occurred()) SWIG_fail;
4802 }
4803 resultobj = SWIG_Py_Void();
4804 return resultobj;
4805 fail:
4806 return NULL;
4807 }
4808
4809
4810 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4811 PyObject *resultobj = 0;
4812 wxSize *arg1 = (wxSize *) 0 ;
4813 wxSize *arg2 = 0 ;
4814 void *argp1 = 0 ;
4815 int res1 = 0 ;
4816 wxSize temp2 ;
4817 PyObject * obj0 = 0 ;
4818 PyObject * obj1 = 0 ;
4819 char * kwnames[] = {
4820 (char *) "self",(char *) "sz", NULL
4821 };
4822
4823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4827 }
4828 arg1 = reinterpret_cast< wxSize * >(argp1);
4829 {
4830 arg2 = &temp2;
4831 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4832 }
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 (arg1)->DecTo((wxSize const &)*arg2);
4836 wxPyEndAllowThreads(__tstate);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 resultobj = SWIG_Py_Void();
4840 return resultobj;
4841 fail:
4842 return NULL;
4843 }
4844
4845
4846 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4847 PyObject *resultobj = 0;
4848 wxSize *arg1 = (wxSize *) 0 ;
4849 int arg2 ;
4850 int arg3 ;
4851 void *argp1 = 0 ;
4852 int res1 = 0 ;
4853 int val2 ;
4854 int ecode2 = 0 ;
4855 int val3 ;
4856 int ecode3 = 0 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 PyObject * obj2 = 0 ;
4860 char * kwnames[] = {
4861 (char *) "self",(char *) "w",(char *) "h", NULL
4862 };
4863
4864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4866 if (!SWIG_IsOK(res1)) {
4867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4868 }
4869 arg1 = reinterpret_cast< wxSize * >(argp1);
4870 ecode2 = SWIG_AsVal_int(obj1, &val2);
4871 if (!SWIG_IsOK(ecode2)) {
4872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4873 }
4874 arg2 = static_cast< int >(val2);
4875 ecode3 = SWIG_AsVal_int(obj2, &val3);
4876 if (!SWIG_IsOK(ecode3)) {
4877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4878 }
4879 arg3 = static_cast< int >(val3);
4880 {
4881 PyThreadState* __tstate = wxPyBeginAllowThreads();
4882 (arg1)->Set(arg2,arg3);
4883 wxPyEndAllowThreads(__tstate);
4884 if (PyErr_Occurred()) SWIG_fail;
4885 }
4886 resultobj = SWIG_Py_Void();
4887 return resultobj;
4888 fail:
4889 return NULL;
4890 }
4891
4892
4893 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4894 PyObject *resultobj = 0;
4895 wxSize *arg1 = (wxSize *) 0 ;
4896 int arg2 ;
4897 void *argp1 = 0 ;
4898 int res1 = 0 ;
4899 int val2 ;
4900 int ecode2 = 0 ;
4901 PyObject * obj0 = 0 ;
4902 PyObject * obj1 = 0 ;
4903 char * kwnames[] = {
4904 (char *) "self",(char *) "w", NULL
4905 };
4906
4907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4909 if (!SWIG_IsOK(res1)) {
4910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4911 }
4912 arg1 = reinterpret_cast< wxSize * >(argp1);
4913 ecode2 = SWIG_AsVal_int(obj1, &val2);
4914 if (!SWIG_IsOK(ecode2)) {
4915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4916 }
4917 arg2 = static_cast< int >(val2);
4918 {
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 (arg1)->SetWidth(arg2);
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 resultobj = SWIG_Py_Void();
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 wxSize *arg1 = (wxSize *) 0 ;
4934 int arg2 ;
4935 void *argp1 = 0 ;
4936 int res1 = 0 ;
4937 int val2 ;
4938 int ecode2 = 0 ;
4939 PyObject * obj0 = 0 ;
4940 PyObject * obj1 = 0 ;
4941 char * kwnames[] = {
4942 (char *) "self",(char *) "h", NULL
4943 };
4944
4945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4947 if (!SWIG_IsOK(res1)) {
4948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4949 }
4950 arg1 = reinterpret_cast< wxSize * >(argp1);
4951 ecode2 = SWIG_AsVal_int(obj1, &val2);
4952 if (!SWIG_IsOK(ecode2)) {
4953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4954 }
4955 arg2 = static_cast< int >(val2);
4956 {
4957 PyThreadState* __tstate = wxPyBeginAllowThreads();
4958 (arg1)->SetHeight(arg2);
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 resultobj = SWIG_Py_Void();
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4970 PyObject *resultobj = 0;
4971 wxSize *arg1 = (wxSize *) 0 ;
4972 int result;
4973 void *argp1 = 0 ;
4974 int res1 = 0 ;
4975 PyObject *swig_obj[1] ;
4976
4977 if (!args) SWIG_fail;
4978 swig_obj[0] = args;
4979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (int)((wxSize const *)arg1)->GetWidth();
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 resultobj = SWIG_From_int(static_cast< int >(result));
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4998 PyObject *resultobj = 0;
4999 wxSize *arg1 = (wxSize *) 0 ;
5000 int result;
5001 void *argp1 = 0 ;
5002 int res1 = 0 ;
5003 PyObject *swig_obj[1] ;
5004
5005 if (!args) SWIG_fail;
5006 swig_obj[0] = args;
5007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5008 if (!SWIG_IsOK(res1)) {
5009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5010 }
5011 arg1 = reinterpret_cast< wxSize * >(argp1);
5012 {
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 result = (int)((wxSize const *)arg1)->GetHeight();
5015 wxPyEndAllowThreads(__tstate);
5016 if (PyErr_Occurred()) SWIG_fail;
5017 }
5018 resultobj = SWIG_From_int(static_cast< int >(result));
5019 return resultobj;
5020 fail:
5021 return NULL;
5022 }
5023
5024
5025 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5026 PyObject *resultobj = 0;
5027 wxSize *arg1 = (wxSize *) 0 ;
5028 bool 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_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5038 }
5039 arg1 = reinterpret_cast< wxSize * >(argp1);
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5043 wxPyEndAllowThreads(__tstate);
5044 if (PyErr_Occurred()) SWIG_fail;
5045 }
5046 {
5047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5048 }
5049 return resultobj;
5050 fail:
5051 return NULL;
5052 }
5053
5054
5055 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5056 PyObject *resultobj = 0;
5057 wxSize *arg1 = (wxSize *) 0 ;
5058 wxSize *arg2 = 0 ;
5059 void *argp1 = 0 ;
5060 int res1 = 0 ;
5061 wxSize temp2 ;
5062 PyObject * obj0 = 0 ;
5063 PyObject * obj1 = 0 ;
5064 char * kwnames[] = {
5065 (char *) "self",(char *) "size", NULL
5066 };
5067
5068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5070 if (!SWIG_IsOK(res1)) {
5071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5072 }
5073 arg1 = reinterpret_cast< wxSize * >(argp1);
5074 {
5075 arg2 = &temp2;
5076 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5077 }
5078 {
5079 PyThreadState* __tstate = wxPyBeginAllowThreads();
5080 (arg1)->SetDefaults((wxSize const &)*arg2);
5081 wxPyEndAllowThreads(__tstate);
5082 if (PyErr_Occurred()) SWIG_fail;
5083 }
5084 resultobj = SWIG_Py_Void();
5085 return resultobj;
5086 fail:
5087 return NULL;
5088 }
5089
5090
5091 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5092 PyObject *resultobj = 0;
5093 wxSize *arg1 = (wxSize *) 0 ;
5094 PyObject *result = 0 ;
5095 void *argp1 = 0 ;
5096 int res1 = 0 ;
5097 PyObject *swig_obj[1] ;
5098
5099 if (!args) SWIG_fail;
5100 swig_obj[0] = args;
5101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5102 if (!SWIG_IsOK(res1)) {
5103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5104 }
5105 arg1 = reinterpret_cast< wxSize * >(argp1);
5106 {
5107 PyThreadState* __tstate = wxPyBeginAllowThreads();
5108 result = (PyObject *)wxSize_Get(arg1);
5109 wxPyEndAllowThreads(__tstate);
5110 if (PyErr_Occurred()) SWIG_fail;
5111 }
5112 resultobj = result;
5113 return resultobj;
5114 fail:
5115 return NULL;
5116 }
5117
5118
5119 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5120 PyObject *obj;
5121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5122 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5123 return SWIG_Py_Void();
5124 }
5125
5126 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5127 return SWIG_Python_InitShadowInstance(args);
5128 }
5129
5130 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5131 PyObject *resultobj = 0;
5132 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5133 double arg2 ;
5134 void *argp1 = 0 ;
5135 int res1 = 0 ;
5136 double val2 ;
5137 int ecode2 = 0 ;
5138 PyObject *swig_obj[2] ;
5139
5140 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5142 if (!SWIG_IsOK(res1)) {
5143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5144 }
5145 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5146 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5147 if (!SWIG_IsOK(ecode2)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5149 }
5150 arg2 = static_cast< double >(val2);
5151 if (arg1) (arg1)->x = arg2;
5152
5153 resultobj = SWIG_Py_Void();
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
5160 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5161 PyObject *resultobj = 0;
5162 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5163 double result;
5164 void *argp1 = 0 ;
5165 int res1 = 0 ;
5166 PyObject *swig_obj[1] ;
5167
5168 if (!args) SWIG_fail;
5169 swig_obj[0] = args;
5170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5171 if (!SWIG_IsOK(res1)) {
5172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5173 }
5174 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5175 result = (double) ((arg1)->x);
5176 resultobj = SWIG_From_double(static_cast< double >(result));
5177 return resultobj;
5178 fail:
5179 return NULL;
5180 }
5181
5182
5183 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5184 PyObject *resultobj = 0;
5185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5186 double arg2 ;
5187 void *argp1 = 0 ;
5188 int res1 = 0 ;
5189 double val2 ;
5190 int ecode2 = 0 ;
5191 PyObject *swig_obj[2] ;
5192
5193 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5195 if (!SWIG_IsOK(res1)) {
5196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5197 }
5198 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5199 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5200 if (!SWIG_IsOK(ecode2)) {
5201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5202 }
5203 arg2 = static_cast< double >(val2);
5204 if (arg1) (arg1)->y = arg2;
5205
5206 resultobj = SWIG_Py_Void();
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5214 PyObject *resultobj = 0;
5215 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5216 double result;
5217 void *argp1 = 0 ;
5218 int res1 = 0 ;
5219 PyObject *swig_obj[1] ;
5220
5221 if (!args) SWIG_fail;
5222 swig_obj[0] = args;
5223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5224 if (!SWIG_IsOK(res1)) {
5225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5226 }
5227 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5228 result = (double) ((arg1)->y);
5229 resultobj = SWIG_From_double(static_cast< double >(result));
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj = 0;
5238 double arg1 = (double) 0.0 ;
5239 double arg2 = (double) 0.0 ;
5240 wxRealPoint *result = 0 ;
5241 double val1 ;
5242 int ecode1 = 0 ;
5243 double val2 ;
5244 int ecode2 = 0 ;
5245 PyObject * obj0 = 0 ;
5246 PyObject * obj1 = 0 ;
5247 char * kwnames[] = {
5248 (char *) "x",(char *) "y", NULL
5249 };
5250
5251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5252 if (obj0) {
5253 ecode1 = SWIG_AsVal_double(obj0, &val1);
5254 if (!SWIG_IsOK(ecode1)) {
5255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5256 }
5257 arg1 = static_cast< double >(val1);
5258 }
5259 if (obj1) {
5260 ecode2 = SWIG_AsVal_double(obj1, &val2);
5261 if (!SWIG_IsOK(ecode2)) {
5262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5263 }
5264 arg2 = static_cast< double >(val2);
5265 }
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5280 PyObject *resultobj = 0;
5281 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5282 void *argp1 = 0 ;
5283 int res1 = 0 ;
5284 PyObject *swig_obj[1] ;
5285
5286 if (!args) SWIG_fail;
5287 swig_obj[0] = args;
5288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5289 if (!SWIG_IsOK(res1)) {
5290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5291 }
5292 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 delete arg1;
5296
5297 wxPyEndAllowThreads(__tstate);
5298 if (PyErr_Occurred()) SWIG_fail;
5299 }
5300 resultobj = SWIG_Py_Void();
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5310 PyObject *arg2 = (PyObject *) 0 ;
5311 bool result;
5312 void *argp1 = 0 ;
5313 int res1 = 0 ;
5314 PyObject * obj0 = 0 ;
5315 PyObject * obj1 = 0 ;
5316 char * kwnames[] = {
5317 (char *) "self",(char *) "other", NULL
5318 };
5319
5320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5324 }
5325 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5326 arg2 = obj1;
5327 {
5328 result = (bool)wxRealPoint___eq__(arg1,arg2);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 {
5332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5333 }
5334 return resultobj;
5335 fail:
5336 return NULL;
5337 }
5338
5339
5340 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5341 PyObject *resultobj = 0;
5342 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5343 PyObject *arg2 = (PyObject *) 0 ;
5344 bool result;
5345 void *argp1 = 0 ;
5346 int res1 = 0 ;
5347 PyObject * obj0 = 0 ;
5348 PyObject * obj1 = 0 ;
5349 char * kwnames[] = {
5350 (char *) "self",(char *) "other", NULL
5351 };
5352
5353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5355 if (!SWIG_IsOK(res1)) {
5356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5357 }
5358 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5359 arg2 = obj1;
5360 {
5361 result = (bool)wxRealPoint___ne__(arg1,arg2);
5362 if (PyErr_Occurred()) SWIG_fail;
5363 }
5364 {
5365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5366 }
5367 return resultobj;
5368 fail:
5369 return NULL;
5370 }
5371
5372
5373 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5374 PyObject *resultobj = 0;
5375 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5376 wxRealPoint *arg2 = 0 ;
5377 wxRealPoint result;
5378 void *argp1 = 0 ;
5379 int res1 = 0 ;
5380 wxRealPoint temp2 ;
5381 PyObject * obj0 = 0 ;
5382 PyObject * obj1 = 0 ;
5383 char * kwnames[] = {
5384 (char *) "self",(char *) "pt", NULL
5385 };
5386
5387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5389 if (!SWIG_IsOK(res1)) {
5390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5391 }
5392 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5393 {
5394 arg2 = &temp2;
5395 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5396 }
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj = 0;
5412 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5413 wxRealPoint *arg2 = 0 ;
5414 wxRealPoint result;
5415 void *argp1 = 0 ;
5416 int res1 = 0 ;
5417 wxRealPoint temp2 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "self",(char *) "pt", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5426 if (!SWIG_IsOK(res1)) {
5427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5428 }
5429 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5430 {
5431 arg2 = &temp2;
5432 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5433 }
5434 {
5435 PyThreadState* __tstate = wxPyBeginAllowThreads();
5436 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5437 wxPyEndAllowThreads(__tstate);
5438 if (PyErr_Occurred()) SWIG_fail;
5439 }
5440 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5441 return resultobj;
5442 fail:
5443 return NULL;
5444 }
5445
5446
5447 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5448 PyObject *resultobj = 0;
5449 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5450 double arg2 ;
5451 double arg3 ;
5452 void *argp1 = 0 ;
5453 int res1 = 0 ;
5454 double val2 ;
5455 int ecode2 = 0 ;
5456 double val3 ;
5457 int ecode3 = 0 ;
5458 PyObject * obj0 = 0 ;
5459 PyObject * obj1 = 0 ;
5460 PyObject * obj2 = 0 ;
5461 char * kwnames[] = {
5462 (char *) "self",(char *) "x",(char *) "y", NULL
5463 };
5464
5465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5467 if (!SWIG_IsOK(res1)) {
5468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5469 }
5470 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5471 ecode2 = SWIG_AsVal_double(obj1, &val2);
5472 if (!SWIG_IsOK(ecode2)) {
5473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5474 }
5475 arg2 = static_cast< double >(val2);
5476 ecode3 = SWIG_AsVal_double(obj2, &val3);
5477 if (!SWIG_IsOK(ecode3)) {
5478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5479 }
5480 arg3 = static_cast< double >(val3);
5481 {
5482 PyThreadState* __tstate = wxPyBeginAllowThreads();
5483 wxRealPoint_Set(arg1,arg2,arg3);
5484 wxPyEndAllowThreads(__tstate);
5485 if (PyErr_Occurred()) SWIG_fail;
5486 }
5487 resultobj = SWIG_Py_Void();
5488 return resultobj;
5489 fail:
5490 return NULL;
5491 }
5492
5493
5494 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5495 PyObject *resultobj = 0;
5496 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5497 PyObject *result = 0 ;
5498 void *argp1 = 0 ;
5499 int res1 = 0 ;
5500 PyObject *swig_obj[1] ;
5501
5502 if (!args) SWIG_fail;
5503 swig_obj[0] = args;
5504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5505 if (!SWIG_IsOK(res1)) {
5506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5507 }
5508 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5509 {
5510 PyThreadState* __tstate = wxPyBeginAllowThreads();
5511 result = (PyObject *)wxRealPoint_Get(arg1);
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 resultobj = result;
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5523 PyObject *obj;
5524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5525 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5526 return SWIG_Py_Void();
5527 }
5528
5529 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5530 return SWIG_Python_InitShadowInstance(args);
5531 }
5532
5533 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5534 PyObject *resultobj = 0;
5535 wxPoint *arg1 = (wxPoint *) 0 ;
5536 int arg2 ;
5537 void *argp1 = 0 ;
5538 int res1 = 0 ;
5539 int val2 ;
5540 int ecode2 = 0 ;
5541 PyObject *swig_obj[2] ;
5542
5543 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5545 if (!SWIG_IsOK(res1)) {
5546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5547 }
5548 arg1 = reinterpret_cast< wxPoint * >(argp1);
5549 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5550 if (!SWIG_IsOK(ecode2)) {
5551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5552 }
5553 arg2 = static_cast< int >(val2);
5554 if (arg1) (arg1)->x = arg2;
5555
5556 resultobj = SWIG_Py_Void();
5557 return resultobj;
5558 fail:
5559 return NULL;
5560 }
5561
5562
5563 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5564 PyObject *resultobj = 0;
5565 wxPoint *arg1 = (wxPoint *) 0 ;
5566 int result;
5567 void *argp1 = 0 ;
5568 int res1 = 0 ;
5569 PyObject *swig_obj[1] ;
5570
5571 if (!args) SWIG_fail;
5572 swig_obj[0] = args;
5573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5574 if (!SWIG_IsOK(res1)) {
5575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5576 }
5577 arg1 = reinterpret_cast< wxPoint * >(argp1);
5578 result = (int) ((arg1)->x);
5579 resultobj = SWIG_From_int(static_cast< int >(result));
5580 return resultobj;
5581 fail:
5582 return NULL;
5583 }
5584
5585
5586 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5587 PyObject *resultobj = 0;
5588 wxPoint *arg1 = (wxPoint *) 0 ;
5589 int arg2 ;
5590 void *argp1 = 0 ;
5591 int res1 = 0 ;
5592 int val2 ;
5593 int ecode2 = 0 ;
5594 PyObject *swig_obj[2] ;
5595
5596 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5598 if (!SWIG_IsOK(res1)) {
5599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5600 }
5601 arg1 = reinterpret_cast< wxPoint * >(argp1);
5602 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5603 if (!SWIG_IsOK(ecode2)) {
5604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5605 }
5606 arg2 = static_cast< int >(val2);
5607 if (arg1) (arg1)->y = arg2;
5608
5609 resultobj = SWIG_Py_Void();
5610 return resultobj;
5611 fail:
5612 return NULL;
5613 }
5614
5615
5616 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5617 PyObject *resultobj = 0;
5618 wxPoint *arg1 = (wxPoint *) 0 ;
5619 int result;
5620 void *argp1 = 0 ;
5621 int res1 = 0 ;
5622 PyObject *swig_obj[1] ;
5623
5624 if (!args) SWIG_fail;
5625 swig_obj[0] = args;
5626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5627 if (!SWIG_IsOK(res1)) {
5628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5629 }
5630 arg1 = reinterpret_cast< wxPoint * >(argp1);
5631 result = (int) ((arg1)->y);
5632 resultobj = SWIG_From_int(static_cast< int >(result));
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj = 0;
5641 int arg1 = (int) 0 ;
5642 int arg2 = (int) 0 ;
5643 wxPoint *result = 0 ;
5644 int val1 ;
5645 int ecode1 = 0 ;
5646 int val2 ;
5647 int ecode2 = 0 ;
5648 PyObject * obj0 = 0 ;
5649 PyObject * obj1 = 0 ;
5650 char * kwnames[] = {
5651 (char *) "x",(char *) "y", NULL
5652 };
5653
5654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5655 if (obj0) {
5656 ecode1 = SWIG_AsVal_int(obj0, &val1);
5657 if (!SWIG_IsOK(ecode1)) {
5658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5659 }
5660 arg1 = static_cast< int >(val1);
5661 }
5662 if (obj1) {
5663 ecode2 = SWIG_AsVal_int(obj1, &val2);
5664 if (!SWIG_IsOK(ecode2)) {
5665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5666 }
5667 arg2 = static_cast< int >(val2);
5668 }
5669 {
5670 PyThreadState* __tstate = wxPyBeginAllowThreads();
5671 result = (wxPoint *)new wxPoint(arg1,arg2);
5672 wxPyEndAllowThreads(__tstate);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5676 return resultobj;
5677 fail:
5678 return NULL;
5679 }
5680
5681
5682 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5683 PyObject *resultobj = 0;
5684 wxPoint *arg1 = (wxPoint *) 0 ;
5685 void *argp1 = 0 ;
5686 int res1 = 0 ;
5687 PyObject *swig_obj[1] ;
5688
5689 if (!args) SWIG_fail;
5690 swig_obj[0] = args;
5691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5692 if (!SWIG_IsOK(res1)) {
5693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5694 }
5695 arg1 = reinterpret_cast< wxPoint * >(argp1);
5696 {
5697 PyThreadState* __tstate = wxPyBeginAllowThreads();
5698 delete arg1;
5699
5700 wxPyEndAllowThreads(__tstate);
5701 if (PyErr_Occurred()) SWIG_fail;
5702 }
5703 resultobj = SWIG_Py_Void();
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 wxPoint *arg1 = (wxPoint *) 0 ;
5713 PyObject *arg2 = (PyObject *) 0 ;
5714 bool result;
5715 void *argp1 = 0 ;
5716 int res1 = 0 ;
5717 PyObject * obj0 = 0 ;
5718 PyObject * obj1 = 0 ;
5719 char * kwnames[] = {
5720 (char *) "self",(char *) "other", NULL
5721 };
5722
5723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5725 if (!SWIG_IsOK(res1)) {
5726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5727 }
5728 arg1 = reinterpret_cast< wxPoint * >(argp1);
5729 arg2 = obj1;
5730 {
5731 result = (bool)wxPoint___eq__(arg1,arg2);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 {
5735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5736 }
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj = 0;
5745 wxPoint *arg1 = (wxPoint *) 0 ;
5746 PyObject *arg2 = (PyObject *) 0 ;
5747 bool result;
5748 void *argp1 = 0 ;
5749 int res1 = 0 ;
5750 PyObject * obj0 = 0 ;
5751 PyObject * obj1 = 0 ;
5752 char * kwnames[] = {
5753 (char *) "self",(char *) "other", NULL
5754 };
5755
5756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5758 if (!SWIG_IsOK(res1)) {
5759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5760 }
5761 arg1 = reinterpret_cast< wxPoint * >(argp1);
5762 arg2 = obj1;
5763 {
5764 result = (bool)wxPoint___ne__(arg1,arg2);
5765 if (PyErr_Occurred()) SWIG_fail;
5766 }
5767 {
5768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5769 }
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = 0;
5778 wxPoint *arg1 = (wxPoint *) 0 ;
5779 wxPoint *arg2 = 0 ;
5780 wxPoint result;
5781 void *argp1 = 0 ;
5782 int res1 = 0 ;
5783 wxPoint temp2 ;
5784 PyObject * obj0 = 0 ;
5785 PyObject * obj1 = 0 ;
5786 char * kwnames[] = {
5787 (char *) "self",(char *) "pt", NULL
5788 };
5789
5790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5792 if (!SWIG_IsOK(res1)) {
5793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5794 }
5795 arg1 = reinterpret_cast< wxPoint * >(argp1);
5796 {
5797 arg2 = &temp2;
5798 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5799 }
5800 {
5801 PyThreadState* __tstate = wxPyBeginAllowThreads();
5802 result = (arg1)->operator +((wxPoint const &)*arg2);
5803 wxPyEndAllowThreads(__tstate);
5804 if (PyErr_Occurred()) SWIG_fail;
5805 }
5806 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5807 return resultobj;
5808 fail:
5809 return NULL;
5810 }
5811
5812
5813 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5814 PyObject *resultobj = 0;
5815 wxPoint *arg1 = (wxPoint *) 0 ;
5816 wxPoint *arg2 = 0 ;
5817 wxPoint result;
5818 void *argp1 = 0 ;
5819 int res1 = 0 ;
5820 wxPoint temp2 ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 char * kwnames[] = {
5824 (char *) "self",(char *) "pt", NULL
5825 };
5826
5827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 {
5834 arg2 = &temp2;
5835 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5836 }
5837 {
5838 PyThreadState* __tstate = wxPyBeginAllowThreads();
5839 result = (arg1)->operator -((wxPoint const &)*arg2);
5840 wxPyEndAllowThreads(__tstate);
5841 if (PyErr_Occurred()) SWIG_fail;
5842 }
5843 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5844 return resultobj;
5845 fail:
5846 return NULL;
5847 }
5848
5849
5850 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5851 PyObject *resultobj = 0;
5852 wxPoint *arg1 = (wxPoint *) 0 ;
5853 wxPoint *arg2 = 0 ;
5854 wxPoint *result = 0 ;
5855 void *argp1 = 0 ;
5856 int res1 = 0 ;
5857 wxPoint temp2 ;
5858 PyObject * obj0 = 0 ;
5859 PyObject * obj1 = 0 ;
5860 char * kwnames[] = {
5861 (char *) "self",(char *) "pt", NULL
5862 };
5863
5864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5866 if (!SWIG_IsOK(res1)) {
5867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5868 }
5869 arg1 = reinterpret_cast< wxPoint * >(argp1);
5870 {
5871 arg2 = &temp2;
5872 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5873 }
5874 {
5875 PyThreadState* __tstate = wxPyBeginAllowThreads();
5876 {
5877 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5878 result = (wxPoint *) &_result_ref;
5879 }
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5891 PyObject *resultobj = 0;
5892 wxPoint *arg1 = (wxPoint *) 0 ;
5893 wxPoint *arg2 = 0 ;
5894 wxPoint *result = 0 ;
5895 void *argp1 = 0 ;
5896 int res1 = 0 ;
5897 wxPoint temp2 ;
5898 PyObject * obj0 = 0 ;
5899 PyObject * obj1 = 0 ;
5900 char * kwnames[] = {
5901 (char *) "self",(char *) "pt", NULL
5902 };
5903
5904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5906 if (!SWIG_IsOK(res1)) {
5907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5908 }
5909 arg1 = reinterpret_cast< wxPoint * >(argp1);
5910 {
5911 arg2 = &temp2;
5912 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5913 }
5914 {
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 {
5917 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5918 result = (wxPoint *) &_result_ref;
5919 }
5920 wxPyEndAllowThreads(__tstate);
5921 if (PyErr_Occurred()) SWIG_fail;
5922 }
5923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5931 PyObject *resultobj = 0;
5932 wxPoint *arg1 = (wxPoint *) 0 ;
5933 long arg2 ;
5934 long arg3 ;
5935 void *argp1 = 0 ;
5936 int res1 = 0 ;
5937 long val2 ;
5938 int ecode2 = 0 ;
5939 long val3 ;
5940 int ecode3 = 0 ;
5941 PyObject * obj0 = 0 ;
5942 PyObject * obj1 = 0 ;
5943 PyObject * obj2 = 0 ;
5944 char * kwnames[] = {
5945 (char *) "self",(char *) "x",(char *) "y", NULL
5946 };
5947
5948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5950 if (!SWIG_IsOK(res1)) {
5951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5952 }
5953 arg1 = reinterpret_cast< wxPoint * >(argp1);
5954 ecode2 = SWIG_AsVal_long(obj1, &val2);
5955 if (!SWIG_IsOK(ecode2)) {
5956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5957 }
5958 arg2 = static_cast< long >(val2);
5959 ecode3 = SWIG_AsVal_long(obj2, &val3);
5960 if (!SWIG_IsOK(ecode3)) {
5961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5962 }
5963 arg3 = static_cast< long >(val3);
5964 {
5965 PyThreadState* __tstate = wxPyBeginAllowThreads();
5966 wxPoint_Set(arg1,arg2,arg3);
5967 wxPyEndAllowThreads(__tstate);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 resultobj = SWIG_Py_Void();
5971 return resultobj;
5972 fail:
5973 return NULL;
5974 }
5975
5976
5977 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5978 PyObject *resultobj = 0;
5979 wxPoint *arg1 = (wxPoint *) 0 ;
5980 PyObject *result = 0 ;
5981 void *argp1 = 0 ;
5982 int res1 = 0 ;
5983 PyObject *swig_obj[1] ;
5984
5985 if (!args) SWIG_fail;
5986 swig_obj[0] = args;
5987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5988 if (!SWIG_IsOK(res1)) {
5989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5990 }
5991 arg1 = reinterpret_cast< wxPoint * >(argp1);
5992 {
5993 PyThreadState* __tstate = wxPyBeginAllowThreads();
5994 result = (PyObject *)wxPoint_Get(arg1);
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 resultobj = result;
5999 return resultobj;
6000 fail:
6001 return NULL;
6002 }
6003
6004
6005 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6006 PyObject *obj;
6007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6008 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6009 return SWIG_Py_Void();
6010 }
6011
6012 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6013 return SWIG_Python_InitShadowInstance(args);
6014 }
6015
6016 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj = 0;
6018 int arg1 = (int) 0 ;
6019 int arg2 = (int) 0 ;
6020 int arg3 = (int) 0 ;
6021 int arg4 = (int) 0 ;
6022 wxRect *result = 0 ;
6023 int val1 ;
6024 int ecode1 = 0 ;
6025 int val2 ;
6026 int ecode2 = 0 ;
6027 int val3 ;
6028 int ecode3 = 0 ;
6029 int val4 ;
6030 int ecode4 = 0 ;
6031 PyObject * obj0 = 0 ;
6032 PyObject * obj1 = 0 ;
6033 PyObject * obj2 = 0 ;
6034 PyObject * obj3 = 0 ;
6035 char * kwnames[] = {
6036 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6037 };
6038
6039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6040 if (obj0) {
6041 ecode1 = SWIG_AsVal_int(obj0, &val1);
6042 if (!SWIG_IsOK(ecode1)) {
6043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6044 }
6045 arg1 = static_cast< int >(val1);
6046 }
6047 if (obj1) {
6048 ecode2 = SWIG_AsVal_int(obj1, &val2);
6049 if (!SWIG_IsOK(ecode2)) {
6050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6051 }
6052 arg2 = static_cast< int >(val2);
6053 }
6054 if (obj2) {
6055 ecode3 = SWIG_AsVal_int(obj2, &val3);
6056 if (!SWIG_IsOK(ecode3)) {
6057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6058 }
6059 arg3 = static_cast< int >(val3);
6060 }
6061 if (obj3) {
6062 ecode4 = SWIG_AsVal_int(obj3, &val4);
6063 if (!SWIG_IsOK(ecode4)) {
6064 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6065 }
6066 arg4 = static_cast< int >(val4);
6067 }
6068 {
6069 PyThreadState* __tstate = wxPyBeginAllowThreads();
6070 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj = 0;
6083 wxPoint *arg1 = 0 ;
6084 wxPoint *arg2 = 0 ;
6085 wxRect *result = 0 ;
6086 wxPoint temp1 ;
6087 wxPoint temp2 ;
6088 PyObject * obj0 = 0 ;
6089 PyObject * obj1 = 0 ;
6090 char * kwnames[] = {
6091 (char *) "topLeft",(char *) "bottomRight", NULL
6092 };
6093
6094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6095 {
6096 arg1 = &temp1;
6097 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6098 }
6099 {
6100 arg2 = &temp2;
6101 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6102 }
6103 {
6104 PyThreadState* __tstate = wxPyBeginAllowThreads();
6105 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6106 wxPyEndAllowThreads(__tstate);
6107 if (PyErr_Occurred()) SWIG_fail;
6108 }
6109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj = 0;
6118 wxPoint *arg1 = 0 ;
6119 wxSize *arg2 = 0 ;
6120 wxRect *result = 0 ;
6121 wxPoint temp1 ;
6122 wxSize temp2 ;
6123 PyObject * obj0 = 0 ;
6124 PyObject * obj1 = 0 ;
6125 char * kwnames[] = {
6126 (char *) "pos",(char *) "size", NULL
6127 };
6128
6129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6130 {
6131 arg1 = &temp1;
6132 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6133 }
6134 {
6135 arg2 = &temp2;
6136 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6137 }
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj = 0;
6153 wxSize *arg1 = 0 ;
6154 wxRect *result = 0 ;
6155 wxSize temp1 ;
6156 PyObject * obj0 = 0 ;
6157 char * kwnames[] = {
6158 (char *) "size", NULL
6159 };
6160
6161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6162 {
6163 arg1 = &temp1;
6164 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6165 }
6166 {
6167 PyThreadState* __tstate = wxPyBeginAllowThreads();
6168 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6169 wxPyEndAllowThreads(__tstate);
6170 if (PyErr_Occurred()) SWIG_fail;
6171 }
6172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6173 return resultobj;
6174 fail:
6175 return NULL;
6176 }
6177
6178
6179 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6180 PyObject *resultobj = 0;
6181 wxRect *arg1 = (wxRect *) 0 ;
6182 void *argp1 = 0 ;
6183 int res1 = 0 ;
6184 PyObject *swig_obj[1] ;
6185
6186 if (!args) SWIG_fail;
6187 swig_obj[0] = args;
6188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6189 if (!SWIG_IsOK(res1)) {
6190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6191 }
6192 arg1 = reinterpret_cast< wxRect * >(argp1);
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 delete arg1;
6196
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 resultobj = SWIG_Py_Void();
6201 return resultobj;
6202 fail:
6203 return NULL;
6204 }
6205
6206
6207 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6208 PyObject *resultobj = 0;
6209 wxRect *arg1 = (wxRect *) 0 ;
6210 int result;
6211 void *argp1 = 0 ;
6212 int res1 = 0 ;
6213 PyObject *swig_obj[1] ;
6214
6215 if (!args) SWIG_fail;
6216 swig_obj[0] = args;
6217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6218 if (!SWIG_IsOK(res1)) {
6219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6220 }
6221 arg1 = reinterpret_cast< wxRect * >(argp1);
6222 {
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 result = (int)((wxRect const *)arg1)->GetX();
6225 wxPyEndAllowThreads(__tstate);
6226 if (PyErr_Occurred()) SWIG_fail;
6227 }
6228 resultobj = SWIG_From_int(static_cast< int >(result));
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6236 PyObject *resultobj = 0;
6237 wxRect *arg1 = (wxRect *) 0 ;
6238 int arg2 ;
6239 void *argp1 = 0 ;
6240 int res1 = 0 ;
6241 int val2 ;
6242 int ecode2 = 0 ;
6243 PyObject * obj0 = 0 ;
6244 PyObject * obj1 = 0 ;
6245 char * kwnames[] = {
6246 (char *) "self",(char *) "x", NULL
6247 };
6248
6249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6251 if (!SWIG_IsOK(res1)) {
6252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6253 }
6254 arg1 = reinterpret_cast< wxRect * >(argp1);
6255 ecode2 = SWIG_AsVal_int(obj1, &val2);
6256 if (!SWIG_IsOK(ecode2)) {
6257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6258 }
6259 arg2 = static_cast< int >(val2);
6260 {
6261 PyThreadState* __tstate = wxPyBeginAllowThreads();
6262 (arg1)->SetX(arg2);
6263 wxPyEndAllowThreads(__tstate);
6264 if (PyErr_Occurred()) SWIG_fail;
6265 }
6266 resultobj = SWIG_Py_Void();
6267 return resultobj;
6268 fail:
6269 return NULL;
6270 }
6271
6272
6273 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6274 PyObject *resultobj = 0;
6275 wxRect *arg1 = (wxRect *) 0 ;
6276 int result;
6277 void *argp1 = 0 ;
6278 int res1 = 0 ;
6279 PyObject *swig_obj[1] ;
6280
6281 if (!args) SWIG_fail;
6282 swig_obj[0] = args;
6283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6284 if (!SWIG_IsOK(res1)) {
6285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6286 }
6287 arg1 = reinterpret_cast< wxRect * >(argp1);
6288 {
6289 PyThreadState* __tstate = wxPyBeginAllowThreads();
6290 result = (int)(arg1)->GetY();
6291 wxPyEndAllowThreads(__tstate);
6292 if (PyErr_Occurred()) SWIG_fail;
6293 }
6294 resultobj = SWIG_From_int(static_cast< int >(result));
6295 return resultobj;
6296 fail:
6297 return NULL;
6298 }
6299
6300
6301 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6302 PyObject *resultobj = 0;
6303 wxRect *arg1 = (wxRect *) 0 ;
6304 int arg2 ;
6305 void *argp1 = 0 ;
6306 int res1 = 0 ;
6307 int val2 ;
6308 int ecode2 = 0 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 char * kwnames[] = {
6312 (char *) "self",(char *) "y", NULL
6313 };
6314
6315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6317 if (!SWIG_IsOK(res1)) {
6318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6319 }
6320 arg1 = reinterpret_cast< wxRect * >(argp1);
6321 ecode2 = SWIG_AsVal_int(obj1, &val2);
6322 if (!SWIG_IsOK(ecode2)) {
6323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6324 }
6325 arg2 = static_cast< int >(val2);
6326 {
6327 PyThreadState* __tstate = wxPyBeginAllowThreads();
6328 (arg1)->SetY(arg2);
6329 wxPyEndAllowThreads(__tstate);
6330 if (PyErr_Occurred()) SWIG_fail;
6331 }
6332 resultobj = SWIG_Py_Void();
6333 return resultobj;
6334 fail:
6335 return NULL;
6336 }
6337
6338
6339 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6340 PyObject *resultobj = 0;
6341 wxRect *arg1 = (wxRect *) 0 ;
6342 int result;
6343 void *argp1 = 0 ;
6344 int res1 = 0 ;
6345 PyObject *swig_obj[1] ;
6346
6347 if (!args) SWIG_fail;
6348 swig_obj[0] = args;
6349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6350 if (!SWIG_IsOK(res1)) {
6351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6352 }
6353 arg1 = reinterpret_cast< wxRect * >(argp1);
6354 {
6355 PyThreadState* __tstate = wxPyBeginAllowThreads();
6356 result = (int)((wxRect const *)arg1)->GetWidth();
6357 wxPyEndAllowThreads(__tstate);
6358 if (PyErr_Occurred()) SWIG_fail;
6359 }
6360 resultobj = SWIG_From_int(static_cast< int >(result));
6361 return resultobj;
6362 fail:
6363 return NULL;
6364 }
6365
6366
6367 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6368 PyObject *resultobj = 0;
6369 wxRect *arg1 = (wxRect *) 0 ;
6370 int arg2 ;
6371 void *argp1 = 0 ;
6372 int res1 = 0 ;
6373 int val2 ;
6374 int ecode2 = 0 ;
6375 PyObject * obj0 = 0 ;
6376 PyObject * obj1 = 0 ;
6377 char * kwnames[] = {
6378 (char *) "self",(char *) "w", NULL
6379 };
6380
6381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6383 if (!SWIG_IsOK(res1)) {
6384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6385 }
6386 arg1 = reinterpret_cast< wxRect * >(argp1);
6387 ecode2 = SWIG_AsVal_int(obj1, &val2);
6388 if (!SWIG_IsOK(ecode2)) {
6389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6390 }
6391 arg2 = static_cast< int >(val2);
6392 {
6393 PyThreadState* __tstate = wxPyBeginAllowThreads();
6394 (arg1)->SetWidth(arg2);
6395 wxPyEndAllowThreads(__tstate);
6396 if (PyErr_Occurred()) SWIG_fail;
6397 }
6398 resultobj = SWIG_Py_Void();
6399 return resultobj;
6400 fail:
6401 return NULL;
6402 }
6403
6404
6405 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6406 PyObject *resultobj = 0;
6407 wxRect *arg1 = (wxRect *) 0 ;
6408 int result;
6409 void *argp1 = 0 ;
6410 int res1 = 0 ;
6411 PyObject *swig_obj[1] ;
6412
6413 if (!args) SWIG_fail;
6414 swig_obj[0] = args;
6415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6416 if (!SWIG_IsOK(res1)) {
6417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6418 }
6419 arg1 = reinterpret_cast< wxRect * >(argp1);
6420 {
6421 PyThreadState* __tstate = wxPyBeginAllowThreads();
6422 result = (int)((wxRect const *)arg1)->GetHeight();
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 resultobj = SWIG_From_int(static_cast< int >(result));
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj = 0;
6435 wxRect *arg1 = (wxRect *) 0 ;
6436 int arg2 ;
6437 void *argp1 = 0 ;
6438 int res1 = 0 ;
6439 int val2 ;
6440 int ecode2 = 0 ;
6441 PyObject * obj0 = 0 ;
6442 PyObject * obj1 = 0 ;
6443 char * kwnames[] = {
6444 (char *) "self",(char *) "h", NULL
6445 };
6446
6447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6449 if (!SWIG_IsOK(res1)) {
6450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6451 }
6452 arg1 = reinterpret_cast< wxRect * >(argp1);
6453 ecode2 = SWIG_AsVal_int(obj1, &val2);
6454 if (!SWIG_IsOK(ecode2)) {
6455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6456 }
6457 arg2 = static_cast< int >(val2);
6458 {
6459 PyThreadState* __tstate = wxPyBeginAllowThreads();
6460 (arg1)->SetHeight(arg2);
6461 wxPyEndAllowThreads(__tstate);
6462 if (PyErr_Occurred()) SWIG_fail;
6463 }
6464 resultobj = SWIG_Py_Void();
6465 return resultobj;
6466 fail:
6467 return NULL;
6468 }
6469
6470
6471 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6472 PyObject *resultobj = 0;
6473 wxRect *arg1 = (wxRect *) 0 ;
6474 wxPoint result;
6475 void *argp1 = 0 ;
6476 int res1 = 0 ;
6477 PyObject *swig_obj[1] ;
6478
6479 if (!args) SWIG_fail;
6480 swig_obj[0] = args;
6481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6482 if (!SWIG_IsOK(res1)) {
6483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6484 }
6485 arg1 = reinterpret_cast< wxRect * >(argp1);
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 result = ((wxRect const *)arg1)->GetPosition();
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6500 PyObject *resultobj = 0;
6501 wxRect *arg1 = (wxRect *) 0 ;
6502 wxPoint *arg2 = 0 ;
6503 void *argp1 = 0 ;
6504 int res1 = 0 ;
6505 wxPoint temp2 ;
6506 PyObject * obj0 = 0 ;
6507 PyObject * obj1 = 0 ;
6508 char * kwnames[] = {
6509 (char *) "self",(char *) "p", NULL
6510 };
6511
6512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6514 if (!SWIG_IsOK(res1)) {
6515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6516 }
6517 arg1 = reinterpret_cast< wxRect * >(argp1);
6518 {
6519 arg2 = &temp2;
6520 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6521 }
6522 {
6523 PyThreadState* __tstate = wxPyBeginAllowThreads();
6524 (arg1)->SetPosition((wxPoint const &)*arg2);
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = SWIG_Py_Void();
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6536 PyObject *resultobj = 0;
6537 wxRect *arg1 = (wxRect *) 0 ;
6538 wxSize result;
6539 void *argp1 = 0 ;
6540 int res1 = 0 ;
6541 PyObject *swig_obj[1] ;
6542
6543 if (!args) SWIG_fail;
6544 swig_obj[0] = args;
6545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6546 if (!SWIG_IsOK(res1)) {
6547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6548 }
6549 arg1 = reinterpret_cast< wxRect * >(argp1);
6550 {
6551 PyThreadState* __tstate = wxPyBeginAllowThreads();
6552 result = ((wxRect const *)arg1)->GetSize();
6553 wxPyEndAllowThreads(__tstate);
6554 if (PyErr_Occurred()) SWIG_fail;
6555 }
6556 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6557 return resultobj;
6558 fail:
6559 return NULL;
6560 }
6561
6562
6563 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6564 PyObject *resultobj = 0;
6565 wxRect *arg1 = (wxRect *) 0 ;
6566 wxSize *arg2 = 0 ;
6567 void *argp1 = 0 ;
6568 int res1 = 0 ;
6569 wxSize temp2 ;
6570 PyObject * obj0 = 0 ;
6571 PyObject * obj1 = 0 ;
6572 char * kwnames[] = {
6573 (char *) "self",(char *) "s", NULL
6574 };
6575
6576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6578 if (!SWIG_IsOK(res1)) {
6579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6580 }
6581 arg1 = reinterpret_cast< wxRect * >(argp1);
6582 {
6583 arg2 = &temp2;
6584 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6585 }
6586 {
6587 PyThreadState* __tstate = wxPyBeginAllowThreads();
6588 (arg1)->SetSize((wxSize const &)*arg2);
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_Py_Void();
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6600 PyObject *resultobj = 0;
6601 wxRect *arg1 = (wxRect *) 0 ;
6602 bool result;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 PyObject *swig_obj[1] ;
6606
6607 if (!args) SWIG_fail;
6608 swig_obj[0] = args;
6609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6610 if (!SWIG_IsOK(res1)) {
6611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6612 }
6613 arg1 = reinterpret_cast< wxRect * >(argp1);
6614 {
6615 PyThreadState* __tstate = wxPyBeginAllowThreads();
6616 result = (bool)((wxRect const *)arg1)->IsEmpty();
6617 wxPyEndAllowThreads(__tstate);
6618 if (PyErr_Occurred()) SWIG_fail;
6619 }
6620 {
6621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6622 }
6623 return resultobj;
6624 fail:
6625 return NULL;
6626 }
6627
6628
6629 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6630 PyObject *resultobj = 0;
6631 wxRect *arg1 = (wxRect *) 0 ;
6632 wxPoint result;
6633 void *argp1 = 0 ;
6634 int res1 = 0 ;
6635 PyObject *swig_obj[1] ;
6636
6637 if (!args) SWIG_fail;
6638 swig_obj[0] = args;
6639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6640 if (!SWIG_IsOK(res1)) {
6641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6642 }
6643 arg1 = reinterpret_cast< wxRect * >(argp1);
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 result = ((wxRect const *)arg1)->GetTopLeft();
6647 wxPyEndAllowThreads(__tstate);
6648 if (PyErr_Occurred()) SWIG_fail;
6649 }
6650 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6658 PyObject *resultobj = 0;
6659 wxRect *arg1 = (wxRect *) 0 ;
6660 wxPoint *arg2 = 0 ;
6661 void *argp1 = 0 ;
6662 int res1 = 0 ;
6663 wxPoint temp2 ;
6664 PyObject * obj0 = 0 ;
6665 PyObject * obj1 = 0 ;
6666 char * kwnames[] = {
6667 (char *) "self",(char *) "p", NULL
6668 };
6669
6670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6672 if (!SWIG_IsOK(res1)) {
6673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6674 }
6675 arg1 = reinterpret_cast< wxRect * >(argp1);
6676 {
6677 arg2 = &temp2;
6678 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6679 }
6680 {
6681 PyThreadState* __tstate = wxPyBeginAllowThreads();
6682 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 resultobj = SWIG_Py_Void();
6687 return resultobj;
6688 fail:
6689 return NULL;
6690 }
6691
6692
6693 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6694 PyObject *resultobj = 0;
6695 wxRect *arg1 = (wxRect *) 0 ;
6696 wxPoint result;
6697 void *argp1 = 0 ;
6698 int res1 = 0 ;
6699 PyObject *swig_obj[1] ;
6700
6701 if (!args) SWIG_fail;
6702 swig_obj[0] = args;
6703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6704 if (!SWIG_IsOK(res1)) {
6705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6706 }
6707 arg1 = reinterpret_cast< wxRect * >(argp1);
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 result = ((wxRect const *)arg1)->GetBottomRight();
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj = 0;
6723 wxRect *arg1 = (wxRect *) 0 ;
6724 wxPoint *arg2 = 0 ;
6725 void *argp1 = 0 ;
6726 int res1 = 0 ;
6727 wxPoint temp2 ;
6728 PyObject * obj0 = 0 ;
6729 PyObject * obj1 = 0 ;
6730 char * kwnames[] = {
6731 (char *) "self",(char *) "p", NULL
6732 };
6733
6734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6736 if (!SWIG_IsOK(res1)) {
6737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6738 }
6739 arg1 = reinterpret_cast< wxRect * >(argp1);
6740 {
6741 arg2 = &temp2;
6742 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6743 }
6744 {
6745 PyThreadState* __tstate = wxPyBeginAllowThreads();
6746 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 resultobj = SWIG_Py_Void();
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6758 PyObject *resultobj = 0;
6759 wxRect *arg1 = (wxRect *) 0 ;
6760 int result;
6761 void *argp1 = 0 ;
6762 int res1 = 0 ;
6763 PyObject *swig_obj[1] ;
6764
6765 if (!args) SWIG_fail;
6766 swig_obj[0] = args;
6767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6768 if (!SWIG_IsOK(res1)) {
6769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6770 }
6771 arg1 = reinterpret_cast< wxRect * >(argp1);
6772 {
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (int)((wxRect const *)arg1)->GetLeft();
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 resultobj = SWIG_From_int(static_cast< int >(result));
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6786 PyObject *resultobj = 0;
6787 wxRect *arg1 = (wxRect *) 0 ;
6788 int result;
6789 void *argp1 = 0 ;
6790 int res1 = 0 ;
6791 PyObject *swig_obj[1] ;
6792
6793 if (!args) SWIG_fail;
6794 swig_obj[0] = args;
6795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6796 if (!SWIG_IsOK(res1)) {
6797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6798 }
6799 arg1 = reinterpret_cast< wxRect * >(argp1);
6800 {
6801 PyThreadState* __tstate = wxPyBeginAllowThreads();
6802 result = (int)((wxRect const *)arg1)->GetTop();
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 resultobj = SWIG_From_int(static_cast< int >(result));
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 SWIGINTERN PyObject *_wrap_Rect_GetBottom(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_GetBottom" "', 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)->GetBottom();
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_GetRight(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_GetRight" "', 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)->GetRight();
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_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6870 PyObject *resultobj = 0;
6871 wxRect *arg1 = (wxRect *) 0 ;
6872 int arg2 ;
6873 void *argp1 = 0 ;
6874 int res1 = 0 ;
6875 int val2 ;
6876 int ecode2 = 0 ;
6877 PyObject * obj0 = 0 ;
6878 PyObject * obj1 = 0 ;
6879 char * kwnames[] = {
6880 (char *) "self",(char *) "left", NULL
6881 };
6882
6883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6885 if (!SWIG_IsOK(res1)) {
6886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6887 }
6888 arg1 = reinterpret_cast< wxRect * >(argp1);
6889 ecode2 = SWIG_AsVal_int(obj1, &val2);
6890 if (!SWIG_IsOK(ecode2)) {
6891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6892 }
6893 arg2 = static_cast< int >(val2);
6894 {
6895 PyThreadState* __tstate = wxPyBeginAllowThreads();
6896 (arg1)->SetLeft(arg2);
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 resultobj = SWIG_Py_Void();
6901 return resultobj;
6902 fail:
6903 return NULL;
6904 }
6905
6906
6907 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6908 PyObject *resultobj = 0;
6909 wxRect *arg1 = (wxRect *) 0 ;
6910 int arg2 ;
6911 void *argp1 = 0 ;
6912 int res1 = 0 ;
6913 int val2 ;
6914 int ecode2 = 0 ;
6915 PyObject * obj0 = 0 ;
6916 PyObject * obj1 = 0 ;
6917 char * kwnames[] = {
6918 (char *) "self",(char *) "right", NULL
6919 };
6920
6921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6925 }
6926 arg1 = reinterpret_cast< wxRect * >(argp1);
6927 ecode2 = SWIG_AsVal_int(obj1, &val2);
6928 if (!SWIG_IsOK(ecode2)) {
6929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6930 }
6931 arg2 = static_cast< int >(val2);
6932 {
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 (arg1)->SetRight(arg2);
6935 wxPyEndAllowThreads(__tstate);
6936 if (PyErr_Occurred()) SWIG_fail;
6937 }
6938 resultobj = SWIG_Py_Void();
6939 return resultobj;
6940 fail:
6941 return NULL;
6942 }
6943
6944
6945 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6946 PyObject *resultobj = 0;
6947 wxRect *arg1 = (wxRect *) 0 ;
6948 int arg2 ;
6949 void *argp1 = 0 ;
6950 int res1 = 0 ;
6951 int val2 ;
6952 int ecode2 = 0 ;
6953 PyObject * obj0 = 0 ;
6954 PyObject * obj1 = 0 ;
6955 char * kwnames[] = {
6956 (char *) "self",(char *) "top", NULL
6957 };
6958
6959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6961 if (!SWIG_IsOK(res1)) {
6962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6963 }
6964 arg1 = reinterpret_cast< wxRect * >(argp1);
6965 ecode2 = SWIG_AsVal_int(obj1, &val2);
6966 if (!SWIG_IsOK(ecode2)) {
6967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6968 }
6969 arg2 = static_cast< int >(val2);
6970 {
6971 PyThreadState* __tstate = wxPyBeginAllowThreads();
6972 (arg1)->SetTop(arg2);
6973 wxPyEndAllowThreads(__tstate);
6974 if (PyErr_Occurred()) SWIG_fail;
6975 }
6976 resultobj = SWIG_Py_Void();
6977 return resultobj;
6978 fail:
6979 return NULL;
6980 }
6981
6982
6983 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6984 PyObject *resultobj = 0;
6985 wxRect *arg1 = (wxRect *) 0 ;
6986 int arg2 ;
6987 void *argp1 = 0 ;
6988 int res1 = 0 ;
6989 int val2 ;
6990 int ecode2 = 0 ;
6991 PyObject * obj0 = 0 ;
6992 PyObject * obj1 = 0 ;
6993 char * kwnames[] = {
6994 (char *) "self",(char *) "bottom", NULL
6995 };
6996
6997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6999 if (!SWIG_IsOK(res1)) {
7000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7001 }
7002 arg1 = reinterpret_cast< wxRect * >(argp1);
7003 ecode2 = SWIG_AsVal_int(obj1, &val2);
7004 if (!SWIG_IsOK(ecode2)) {
7005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7006 }
7007 arg2 = static_cast< int >(val2);
7008 {
7009 PyThreadState* __tstate = wxPyBeginAllowThreads();
7010 (arg1)->SetBottom(arg2);
7011 wxPyEndAllowThreads(__tstate);
7012 if (PyErr_Occurred()) SWIG_fail;
7013 }
7014 resultobj = SWIG_Py_Void();
7015 return resultobj;
7016 fail:
7017 return NULL;
7018 }
7019
7020
7021 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7022 PyObject *resultobj = 0;
7023 wxRect *arg1 = (wxRect *) 0 ;
7024 int arg2 ;
7025 int arg3 ;
7026 wxRect *result = 0 ;
7027 void *argp1 = 0 ;
7028 int res1 = 0 ;
7029 int val2 ;
7030 int ecode2 = 0 ;
7031 int val3 ;
7032 int ecode3 = 0 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 PyObject * obj2 = 0 ;
7036 char * kwnames[] = {
7037 (char *) "self",(char *) "dx",(char *) "dy", NULL
7038 };
7039
7040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7042 if (!SWIG_IsOK(res1)) {
7043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7044 }
7045 arg1 = reinterpret_cast< wxRect * >(argp1);
7046 ecode2 = SWIG_AsVal_int(obj1, &val2);
7047 if (!SWIG_IsOK(ecode2)) {
7048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7049 }
7050 arg2 = static_cast< int >(val2);
7051 ecode3 = SWIG_AsVal_int(obj2, &val3);
7052 if (!SWIG_IsOK(ecode3)) {
7053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7054 }
7055 arg3 = static_cast< int >(val3);
7056 {
7057 PyThreadState* __tstate = wxPyBeginAllowThreads();
7058 {
7059 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7060 result = (wxRect *) &_result_ref;
7061 }
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxRect *arg1 = (wxRect *) 0 ;
7075 int arg2 ;
7076 int arg3 ;
7077 wxRect *result = 0 ;
7078 void *argp1 = 0 ;
7079 int res1 = 0 ;
7080 int val2 ;
7081 int ecode2 = 0 ;
7082 int val3 ;
7083 int ecode3 = 0 ;
7084 PyObject * obj0 = 0 ;
7085 PyObject * obj1 = 0 ;
7086 PyObject * obj2 = 0 ;
7087 char * kwnames[] = {
7088 (char *) "self",(char *) "dx",(char *) "dy", NULL
7089 };
7090
7091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7095 }
7096 arg1 = reinterpret_cast< wxRect * >(argp1);
7097 ecode2 = SWIG_AsVal_int(obj1, &val2);
7098 if (!SWIG_IsOK(ecode2)) {
7099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7100 }
7101 arg2 = static_cast< int >(val2);
7102 ecode3 = SWIG_AsVal_int(obj2, &val3);
7103 if (!SWIG_IsOK(ecode3)) {
7104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7105 }
7106 arg3 = static_cast< int >(val3);
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 {
7110 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7111 result = (wxRect *) &_result_ref;
7112 }
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj = 0;
7125 wxRect *arg1 = (wxRect *) 0 ;
7126 int arg2 ;
7127 int arg3 ;
7128 void *argp1 = 0 ;
7129 int res1 = 0 ;
7130 int val2 ;
7131 int ecode2 = 0 ;
7132 int val3 ;
7133 int ecode3 = 0 ;
7134 PyObject * obj0 = 0 ;
7135 PyObject * obj1 = 0 ;
7136 PyObject * obj2 = 0 ;
7137 char * kwnames[] = {
7138 (char *) "self",(char *) "dx",(char *) "dy", NULL
7139 };
7140
7141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7143 if (!SWIG_IsOK(res1)) {
7144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7145 }
7146 arg1 = reinterpret_cast< wxRect * >(argp1);
7147 ecode2 = SWIG_AsVal_int(obj1, &val2);
7148 if (!SWIG_IsOK(ecode2)) {
7149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7150 }
7151 arg2 = static_cast< int >(val2);
7152 ecode3 = SWIG_AsVal_int(obj2, &val3);
7153 if (!SWIG_IsOK(ecode3)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7155 }
7156 arg3 = static_cast< int >(val3);
7157 {
7158 PyThreadState* __tstate = wxPyBeginAllowThreads();
7159 (arg1)->Offset(arg2,arg3);
7160 wxPyEndAllowThreads(__tstate);
7161 if (PyErr_Occurred()) SWIG_fail;
7162 }
7163 resultobj = SWIG_Py_Void();
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj = 0;
7172 wxRect *arg1 = (wxRect *) 0 ;
7173 wxPoint *arg2 = 0 ;
7174 void *argp1 = 0 ;
7175 int res1 = 0 ;
7176 wxPoint temp2 ;
7177 PyObject * obj0 = 0 ;
7178 PyObject * obj1 = 0 ;
7179 char * kwnames[] = {
7180 (char *) "self",(char *) "pt", NULL
7181 };
7182
7183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7185 if (!SWIG_IsOK(res1)) {
7186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7187 }
7188 arg1 = reinterpret_cast< wxRect * >(argp1);
7189 {
7190 arg2 = &temp2;
7191 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7192 }
7193 {
7194 PyThreadState* __tstate = wxPyBeginAllowThreads();
7195 (arg1)->Offset((wxPoint const &)*arg2);
7196 wxPyEndAllowThreads(__tstate);
7197 if (PyErr_Occurred()) SWIG_fail;
7198 }
7199 resultobj = SWIG_Py_Void();
7200 return resultobj;
7201 fail:
7202 return NULL;
7203 }
7204
7205
7206 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7207 PyObject *resultobj = 0;
7208 wxRect *arg1 = (wxRect *) 0 ;
7209 wxRect *arg2 = 0 ;
7210 wxRect result;
7211 void *argp1 = 0 ;
7212 int res1 = 0 ;
7213 wxRect temp2 ;
7214 PyObject * obj0 = 0 ;
7215 PyObject * obj1 = 0 ;
7216 char * kwnames[] = {
7217 (char *) "self",(char *) "rect", NULL
7218 };
7219
7220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7222 if (!SWIG_IsOK(res1)) {
7223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7224 }
7225 arg1 = reinterpret_cast< wxRect * >(argp1);
7226 {
7227 arg2 = &temp2;
7228 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7229 }
7230 {
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 result = (arg1)->Intersect((wxRect const &)*arg2);
7233 wxPyEndAllowThreads(__tstate);
7234 if (PyErr_Occurred()) SWIG_fail;
7235 }
7236 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7237 return resultobj;
7238 fail:
7239 return NULL;
7240 }
7241
7242
7243 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7244 PyObject *resultobj = 0;
7245 wxRect *arg1 = (wxRect *) 0 ;
7246 wxRect *arg2 = 0 ;
7247 wxRect result;
7248 void *argp1 = 0 ;
7249 int res1 = 0 ;
7250 wxRect temp2 ;
7251 PyObject * obj0 = 0 ;
7252 PyObject * obj1 = 0 ;
7253 char * kwnames[] = {
7254 (char *) "self",(char *) "rect", NULL
7255 };
7256
7257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7259 if (!SWIG_IsOK(res1)) {
7260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7261 }
7262 arg1 = reinterpret_cast< wxRect * >(argp1);
7263 {
7264 arg2 = &temp2;
7265 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7266 }
7267 {
7268 PyThreadState* __tstate = wxPyBeginAllowThreads();
7269 result = (arg1)->Union((wxRect const &)*arg2);
7270 wxPyEndAllowThreads(__tstate);
7271 if (PyErr_Occurred()) SWIG_fail;
7272 }
7273 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7274 return resultobj;
7275 fail:
7276 return NULL;
7277 }
7278
7279
7280 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7281 PyObject *resultobj = 0;
7282 wxRect *arg1 = (wxRect *) 0 ;
7283 wxRect *arg2 = 0 ;
7284 wxRect result;
7285 void *argp1 = 0 ;
7286 int res1 = 0 ;
7287 wxRect temp2 ;
7288 PyObject * obj0 = 0 ;
7289 PyObject * obj1 = 0 ;
7290 char * kwnames[] = {
7291 (char *) "self",(char *) "rect", NULL
7292 };
7293
7294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7296 if (!SWIG_IsOK(res1)) {
7297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7298 }
7299 arg1 = reinterpret_cast< wxRect * >(argp1);
7300 {
7301 arg2 = &temp2;
7302 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7303 }
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7307 wxPyEndAllowThreads(__tstate);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj = 0;
7319 wxRect *arg1 = (wxRect *) 0 ;
7320 wxRect *arg2 = 0 ;
7321 wxRect *result = 0 ;
7322 void *argp1 = 0 ;
7323 int res1 = 0 ;
7324 wxRect temp2 ;
7325 PyObject * obj0 = 0 ;
7326 PyObject * obj1 = 0 ;
7327 char * kwnames[] = {
7328 (char *) "self",(char *) "rect", NULL
7329 };
7330
7331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7333 if (!SWIG_IsOK(res1)) {
7334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7335 }
7336 arg1 = reinterpret_cast< wxRect * >(argp1);
7337 {
7338 arg2 = &temp2;
7339 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7340 }
7341 {
7342 PyThreadState* __tstate = wxPyBeginAllowThreads();
7343 {
7344 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7345 result = (wxRect *) &_result_ref;
7346 }
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7358 PyObject *resultobj = 0;
7359 wxRect *arg1 = (wxRect *) 0 ;
7360 PyObject *arg2 = (PyObject *) 0 ;
7361 bool result;
7362 void *argp1 = 0 ;
7363 int res1 = 0 ;
7364 PyObject * obj0 = 0 ;
7365 PyObject * obj1 = 0 ;
7366 char * kwnames[] = {
7367 (char *) "self",(char *) "other", NULL
7368 };
7369
7370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7372 if (!SWIG_IsOK(res1)) {
7373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7374 }
7375 arg1 = reinterpret_cast< wxRect * >(argp1);
7376 arg2 = obj1;
7377 {
7378 result = (bool)wxRect___eq__(arg1,arg2);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 {
7382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7383 }
7384 return resultobj;
7385 fail:
7386 return NULL;
7387 }
7388
7389
7390 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7391 PyObject *resultobj = 0;
7392 wxRect *arg1 = (wxRect *) 0 ;
7393 PyObject *arg2 = (PyObject *) 0 ;
7394 bool result;
7395 void *argp1 = 0 ;
7396 int res1 = 0 ;
7397 PyObject * obj0 = 0 ;
7398 PyObject * obj1 = 0 ;
7399 char * kwnames[] = {
7400 (char *) "self",(char *) "other", NULL
7401 };
7402
7403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7405 if (!SWIG_IsOK(res1)) {
7406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7407 }
7408 arg1 = reinterpret_cast< wxRect * >(argp1);
7409 arg2 = obj1;
7410 {
7411 result = (bool)wxRect___ne__(arg1,arg2);
7412 if (PyErr_Occurred()) SWIG_fail;
7413 }
7414 {
7415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7416 }
7417 return resultobj;
7418 fail:
7419 return NULL;
7420 }
7421
7422
7423 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7424 PyObject *resultobj = 0;
7425 wxRect *arg1 = (wxRect *) 0 ;
7426 int arg2 ;
7427 int arg3 ;
7428 bool result;
7429 void *argp1 = 0 ;
7430 int res1 = 0 ;
7431 int val2 ;
7432 int ecode2 = 0 ;
7433 int val3 ;
7434 int ecode3 = 0 ;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 PyObject * obj2 = 0 ;
7438 char * kwnames[] = {
7439 (char *) "self",(char *) "x",(char *) "y", NULL
7440 };
7441
7442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7444 if (!SWIG_IsOK(res1)) {
7445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7446 }
7447 arg1 = reinterpret_cast< wxRect * >(argp1);
7448 ecode2 = SWIG_AsVal_int(obj1, &val2);
7449 if (!SWIG_IsOK(ecode2)) {
7450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7451 }
7452 arg2 = static_cast< int >(val2);
7453 ecode3 = SWIG_AsVal_int(obj2, &val3);
7454 if (!SWIG_IsOK(ecode3)) {
7455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7456 }
7457 arg3 = static_cast< int >(val3);
7458 {
7459 PyThreadState* __tstate = wxPyBeginAllowThreads();
7460 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 {
7465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7466 }
7467 return resultobj;
7468 fail:
7469 return NULL;
7470 }
7471
7472
7473 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7474 PyObject *resultobj = 0;
7475 wxRect *arg1 = (wxRect *) 0 ;
7476 wxPoint *arg2 = 0 ;
7477 bool result;
7478 void *argp1 = 0 ;
7479 int res1 = 0 ;
7480 wxPoint temp2 ;
7481 PyObject * obj0 = 0 ;
7482 PyObject * obj1 = 0 ;
7483 char * kwnames[] = {
7484 (char *) "self",(char *) "pt", NULL
7485 };
7486
7487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7489 if (!SWIG_IsOK(res1)) {
7490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7491 }
7492 arg1 = reinterpret_cast< wxRect * >(argp1);
7493 {
7494 arg2 = &temp2;
7495 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7496 }
7497 {
7498 PyThreadState* __tstate = wxPyBeginAllowThreads();
7499 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 {
7504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7505 }
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj = 0;
7514 wxRect *arg1 = (wxRect *) 0 ;
7515 wxRect *arg2 = 0 ;
7516 bool result;
7517 void *argp1 = 0 ;
7518 int res1 = 0 ;
7519 wxRect temp2 ;
7520 PyObject * obj0 = 0 ;
7521 PyObject * obj1 = 0 ;
7522 char * kwnames[] = {
7523 (char *) "self",(char *) "rect", NULL
7524 };
7525
7526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7528 if (!SWIG_IsOK(res1)) {
7529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7530 }
7531 arg1 = reinterpret_cast< wxRect * >(argp1);
7532 {
7533 arg2 = &temp2;
7534 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7535 }
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 {
7543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7544 }
7545 return resultobj;
7546 fail:
7547 return NULL;
7548 }
7549
7550
7551 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7552 PyObject *resultobj = 0;
7553 wxRect *arg1 = (wxRect *) 0 ;
7554 wxRect *arg2 = 0 ;
7555 int arg3 = (int) wxBOTH ;
7556 wxRect result;
7557 void *argp1 = 0 ;
7558 int res1 = 0 ;
7559 wxRect temp2 ;
7560 int val3 ;
7561 int ecode3 = 0 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 PyObject * obj2 = 0 ;
7565 char * kwnames[] = {
7566 (char *) "self",(char *) "r",(char *) "dir", NULL
7567 };
7568
7569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7571 if (!SWIG_IsOK(res1)) {
7572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7573 }
7574 arg1 = reinterpret_cast< wxRect * >(argp1);
7575 {
7576 arg2 = &temp2;
7577 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7578 }
7579 if (obj2) {
7580 ecode3 = SWIG_AsVal_int(obj2, &val3);
7581 if (!SWIG_IsOK(ecode3)) {
7582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7583 }
7584 arg3 = static_cast< int >(val3);
7585 }
7586 {
7587 PyThreadState* __tstate = wxPyBeginAllowThreads();
7588 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7589 wxPyEndAllowThreads(__tstate);
7590 if (PyErr_Occurred()) SWIG_fail;
7591 }
7592 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7593 return resultobj;
7594 fail:
7595 return NULL;
7596 }
7597
7598
7599 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7600 PyObject *resultobj = 0;
7601 wxRect *arg1 = (wxRect *) 0 ;
7602 int arg2 ;
7603 void *argp1 = 0 ;
7604 int res1 = 0 ;
7605 int val2 ;
7606 int ecode2 = 0 ;
7607 PyObject *swig_obj[2] ;
7608
7609 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7611 if (!SWIG_IsOK(res1)) {
7612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7613 }
7614 arg1 = reinterpret_cast< wxRect * >(argp1);
7615 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7616 if (!SWIG_IsOK(ecode2)) {
7617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7618 }
7619 arg2 = static_cast< int >(val2);
7620 if (arg1) (arg1)->x = arg2;
7621
7622 resultobj = SWIG_Py_Void();
7623 return resultobj;
7624 fail:
7625 return NULL;
7626 }
7627
7628
7629 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7630 PyObject *resultobj = 0;
7631 wxRect *arg1 = (wxRect *) 0 ;
7632 int result;
7633 void *argp1 = 0 ;
7634 int res1 = 0 ;
7635 PyObject *swig_obj[1] ;
7636
7637 if (!args) SWIG_fail;
7638 swig_obj[0] = args;
7639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7640 if (!SWIG_IsOK(res1)) {
7641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7642 }
7643 arg1 = reinterpret_cast< wxRect * >(argp1);
7644 result = (int) ((arg1)->x);
7645 resultobj = SWIG_From_int(static_cast< int >(result));
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7653 PyObject *resultobj = 0;
7654 wxRect *arg1 = (wxRect *) 0 ;
7655 int arg2 ;
7656 void *argp1 = 0 ;
7657 int res1 = 0 ;
7658 int val2 ;
7659 int ecode2 = 0 ;
7660 PyObject *swig_obj[2] ;
7661
7662 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7664 if (!SWIG_IsOK(res1)) {
7665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7666 }
7667 arg1 = reinterpret_cast< wxRect * >(argp1);
7668 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7669 if (!SWIG_IsOK(ecode2)) {
7670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7671 }
7672 arg2 = static_cast< int >(val2);
7673 if (arg1) (arg1)->y = arg2;
7674
7675 resultobj = SWIG_Py_Void();
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7683 PyObject *resultobj = 0;
7684 wxRect *arg1 = (wxRect *) 0 ;
7685 int result;
7686 void *argp1 = 0 ;
7687 int res1 = 0 ;
7688 PyObject *swig_obj[1] ;
7689
7690 if (!args) SWIG_fail;
7691 swig_obj[0] = args;
7692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7693 if (!SWIG_IsOK(res1)) {
7694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7695 }
7696 arg1 = reinterpret_cast< wxRect * >(argp1);
7697 result = (int) ((arg1)->y);
7698 resultobj = SWIG_From_int(static_cast< int >(result));
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7706 PyObject *resultobj = 0;
7707 wxRect *arg1 = (wxRect *) 0 ;
7708 int arg2 ;
7709 void *argp1 = 0 ;
7710 int res1 = 0 ;
7711 int val2 ;
7712 int ecode2 = 0 ;
7713 PyObject *swig_obj[2] ;
7714
7715 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7717 if (!SWIG_IsOK(res1)) {
7718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7719 }
7720 arg1 = reinterpret_cast< wxRect * >(argp1);
7721 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7722 if (!SWIG_IsOK(ecode2)) {
7723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7724 }
7725 arg2 = static_cast< int >(val2);
7726 if (arg1) (arg1)->width = arg2;
7727
7728 resultobj = SWIG_Py_Void();
7729 return resultobj;
7730 fail:
7731 return NULL;
7732 }
7733
7734
7735 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7736 PyObject *resultobj = 0;
7737 wxRect *arg1 = (wxRect *) 0 ;
7738 int result;
7739 void *argp1 = 0 ;
7740 int res1 = 0 ;
7741 PyObject *swig_obj[1] ;
7742
7743 if (!args) SWIG_fail;
7744 swig_obj[0] = args;
7745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7746 if (!SWIG_IsOK(res1)) {
7747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7748 }
7749 arg1 = reinterpret_cast< wxRect * >(argp1);
7750 result = (int) ((arg1)->width);
7751 resultobj = SWIG_From_int(static_cast< int >(result));
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7759 PyObject *resultobj = 0;
7760 wxRect *arg1 = (wxRect *) 0 ;
7761 int arg2 ;
7762 void *argp1 = 0 ;
7763 int res1 = 0 ;
7764 int val2 ;
7765 int ecode2 = 0 ;
7766 PyObject *swig_obj[2] ;
7767
7768 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7770 if (!SWIG_IsOK(res1)) {
7771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7772 }
7773 arg1 = reinterpret_cast< wxRect * >(argp1);
7774 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7775 if (!SWIG_IsOK(ecode2)) {
7776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7777 }
7778 arg2 = static_cast< int >(val2);
7779 if (arg1) (arg1)->height = arg2;
7780
7781 resultobj = SWIG_Py_Void();
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7789 PyObject *resultobj = 0;
7790 wxRect *arg1 = (wxRect *) 0 ;
7791 int result;
7792 void *argp1 = 0 ;
7793 int res1 = 0 ;
7794 PyObject *swig_obj[1] ;
7795
7796 if (!args) SWIG_fail;
7797 swig_obj[0] = args;
7798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7799 if (!SWIG_IsOK(res1)) {
7800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7801 }
7802 arg1 = reinterpret_cast< wxRect * >(argp1);
7803 result = (int) ((arg1)->height);
7804 resultobj = SWIG_From_int(static_cast< int >(result));
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj = 0;
7813 wxRect *arg1 = (wxRect *) 0 ;
7814 int arg2 = (int) 0 ;
7815 int arg3 = (int) 0 ;
7816 int arg4 = (int) 0 ;
7817 int arg5 = (int) 0 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 int val2 ;
7821 int ecode2 = 0 ;
7822 int val3 ;
7823 int ecode3 = 0 ;
7824 int val4 ;
7825 int ecode4 = 0 ;
7826 int val5 ;
7827 int ecode5 = 0 ;
7828 PyObject * obj0 = 0 ;
7829 PyObject * obj1 = 0 ;
7830 PyObject * obj2 = 0 ;
7831 PyObject * obj3 = 0 ;
7832 PyObject * obj4 = 0 ;
7833 char * kwnames[] = {
7834 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7835 };
7836
7837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7839 if (!SWIG_IsOK(res1)) {
7840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7841 }
7842 arg1 = reinterpret_cast< wxRect * >(argp1);
7843 if (obj1) {
7844 ecode2 = SWIG_AsVal_int(obj1, &val2);
7845 if (!SWIG_IsOK(ecode2)) {
7846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7847 }
7848 arg2 = static_cast< int >(val2);
7849 }
7850 if (obj2) {
7851 ecode3 = SWIG_AsVal_int(obj2, &val3);
7852 if (!SWIG_IsOK(ecode3)) {
7853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7854 }
7855 arg3 = static_cast< int >(val3);
7856 }
7857 if (obj3) {
7858 ecode4 = SWIG_AsVal_int(obj3, &val4);
7859 if (!SWIG_IsOK(ecode4)) {
7860 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7861 }
7862 arg4 = static_cast< int >(val4);
7863 }
7864 if (obj4) {
7865 ecode5 = SWIG_AsVal_int(obj4, &val5);
7866 if (!SWIG_IsOK(ecode5)) {
7867 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7868 }
7869 arg5 = static_cast< int >(val5);
7870 }
7871 {
7872 PyThreadState* __tstate = wxPyBeginAllowThreads();
7873 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7874 wxPyEndAllowThreads(__tstate);
7875 if (PyErr_Occurred()) SWIG_fail;
7876 }
7877 resultobj = SWIG_Py_Void();
7878 return resultobj;
7879 fail:
7880 return NULL;
7881 }
7882
7883
7884 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7885 PyObject *resultobj = 0;
7886 wxRect *arg1 = (wxRect *) 0 ;
7887 PyObject *result = 0 ;
7888 void *argp1 = 0 ;
7889 int res1 = 0 ;
7890 PyObject *swig_obj[1] ;
7891
7892 if (!args) SWIG_fail;
7893 swig_obj[0] = args;
7894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7895 if (!SWIG_IsOK(res1)) {
7896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7897 }
7898 arg1 = reinterpret_cast< wxRect * >(argp1);
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 result = (PyObject *)wxRect_Get(arg1);
7902 wxPyEndAllowThreads(__tstate);
7903 if (PyErr_Occurred()) SWIG_fail;
7904 }
7905 resultobj = result;
7906 return resultobj;
7907 fail:
7908 return NULL;
7909 }
7910
7911
7912 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7913 PyObject *obj;
7914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7915 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7916 return SWIG_Py_Void();
7917 }
7918
7919 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7920 return SWIG_Python_InitShadowInstance(args);
7921 }
7922
7923 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj = 0;
7925 wxRect *arg1 = (wxRect *) 0 ;
7926 wxRect *arg2 = (wxRect *) 0 ;
7927 PyObject *result = 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 void *argp2 = 0 ;
7931 int res2 = 0 ;
7932 PyObject * obj0 = 0 ;
7933 PyObject * obj1 = 0 ;
7934 char * kwnames[] = {
7935 (char *) "r1",(char *) "r2", NULL
7936 };
7937
7938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7940 if (!SWIG_IsOK(res1)) {
7941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7942 }
7943 arg1 = reinterpret_cast< wxRect * >(argp1);
7944 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7945 if (!SWIG_IsOK(res2)) {
7946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7947 }
7948 arg2 = reinterpret_cast< wxRect * >(argp2);
7949 {
7950 if (!wxPyCheckForApp()) SWIG_fail;
7951 PyThreadState* __tstate = wxPyBeginAllowThreads();
7952 result = (PyObject *)wxIntersectRect(arg1,arg2);
7953 wxPyEndAllowThreads(__tstate);
7954 if (PyErr_Occurred()) SWIG_fail;
7955 }
7956 resultobj = result;
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7964 PyObject *resultobj = 0;
7965 double arg1 = (double) 0.0 ;
7966 double arg2 = (double) 0.0 ;
7967 wxPoint2D *result = 0 ;
7968 double val1 ;
7969 int ecode1 = 0 ;
7970 double val2 ;
7971 int ecode2 = 0 ;
7972 PyObject * obj0 = 0 ;
7973 PyObject * obj1 = 0 ;
7974 char * kwnames[] = {
7975 (char *) "x",(char *) "y", NULL
7976 };
7977
7978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7979 if (obj0) {
7980 ecode1 = SWIG_AsVal_double(obj0, &val1);
7981 if (!SWIG_IsOK(ecode1)) {
7982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7983 }
7984 arg1 = static_cast< double >(val1);
7985 }
7986 if (obj1) {
7987 ecode2 = SWIG_AsVal_double(obj1, &val2);
7988 if (!SWIG_IsOK(ecode2)) {
7989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7990 }
7991 arg2 = static_cast< double >(val2);
7992 }
7993 {
7994 PyThreadState* __tstate = wxPyBeginAllowThreads();
7995 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7996 wxPyEndAllowThreads(__tstate);
7997 if (PyErr_Occurred()) SWIG_fail;
7998 }
7999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8007 PyObject *resultobj = 0;
8008 wxPoint2D *arg1 = 0 ;
8009 wxPoint2D *result = 0 ;
8010 wxPoint2D temp1 ;
8011 PyObject * obj0 = 0 ;
8012 char * kwnames[] = {
8013 (char *) "pt", NULL
8014 };
8015
8016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8017 {
8018 arg1 = &temp1;
8019 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8020 }
8021 {
8022 PyThreadState* __tstate = wxPyBeginAllowThreads();
8023 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8024 wxPyEndAllowThreads(__tstate);
8025 if (PyErr_Occurred()) SWIG_fail;
8026 }
8027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8028 return resultobj;
8029 fail:
8030 return NULL;
8031 }
8032
8033
8034 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8035 PyObject *resultobj = 0;
8036 wxPoint *arg1 = 0 ;
8037 wxPoint2D *result = 0 ;
8038 wxPoint temp1 ;
8039 PyObject * obj0 = 0 ;
8040 char * kwnames[] = {
8041 (char *) "pt", NULL
8042 };
8043
8044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8045 {
8046 arg1 = &temp1;
8047 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8048 }
8049 {
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8052 wxPyEndAllowThreads(__tstate);
8053 if (PyErr_Occurred()) SWIG_fail;
8054 }
8055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8056 return resultobj;
8057 fail:
8058 return NULL;
8059 }
8060
8061
8062 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8063 PyObject *resultobj = 0;
8064 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8065 int *arg2 = (int *) 0 ;
8066 int *arg3 = (int *) 0 ;
8067 void *argp1 = 0 ;
8068 int res1 = 0 ;
8069 int temp2 ;
8070 int res2 = SWIG_TMPOBJ ;
8071 int temp3 ;
8072 int res3 = SWIG_TMPOBJ ;
8073 PyObject *swig_obj[1] ;
8074
8075 arg2 = &temp2;
8076 arg3 = &temp3;
8077 if (!args) SWIG_fail;
8078 swig_obj[0] = args;
8079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8080 if (!SWIG_IsOK(res1)) {
8081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8082 }
8083 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8084 {
8085 PyThreadState* __tstate = wxPyBeginAllowThreads();
8086 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8087 wxPyEndAllowThreads(__tstate);
8088 if (PyErr_Occurred()) SWIG_fail;
8089 }
8090 resultobj = SWIG_Py_Void();
8091 if (SWIG_IsTmpObj(res2)) {
8092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8093 } else {
8094 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8096 }
8097 if (SWIG_IsTmpObj(res3)) {
8098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8099 } else {
8100 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8102 }
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8110 PyObject *resultobj = 0;
8111 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8112 int *arg2 = (int *) 0 ;
8113 int *arg3 = (int *) 0 ;
8114 void *argp1 = 0 ;
8115 int res1 = 0 ;
8116 int temp2 ;
8117 int res2 = SWIG_TMPOBJ ;
8118 int temp3 ;
8119 int res3 = SWIG_TMPOBJ ;
8120 PyObject *swig_obj[1] ;
8121
8122 arg2 = &temp2;
8123 arg3 = &temp3;
8124 if (!args) SWIG_fail;
8125 swig_obj[0] = args;
8126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8127 if (!SWIG_IsOK(res1)) {
8128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8129 }
8130 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_Py_Void();
8138 if (SWIG_IsTmpObj(res2)) {
8139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8140 } else {
8141 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8143 }
8144 if (SWIG_IsTmpObj(res3)) {
8145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8146 } else {
8147 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8149 }
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8157 PyObject *resultobj = 0;
8158 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8159 double result;
8160 void *argp1 = 0 ;
8161 int res1 = 0 ;
8162 PyObject *swig_obj[1] ;
8163
8164 if (!args) SWIG_fail;
8165 swig_obj[0] = args;
8166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8167 if (!SWIG_IsOK(res1)) {
8168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8169 }
8170 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8171 {
8172 PyThreadState* __tstate = wxPyBeginAllowThreads();
8173 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8174 wxPyEndAllowThreads(__tstate);
8175 if (PyErr_Occurred()) SWIG_fail;
8176 }
8177 resultobj = SWIG_From_double(static_cast< double >(result));
8178 return resultobj;
8179 fail:
8180 return NULL;
8181 }
8182
8183
8184 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8185 PyObject *resultobj = 0;
8186 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8187 double result;
8188 void *argp1 = 0 ;
8189 int res1 = 0 ;
8190 PyObject *swig_obj[1] ;
8191
8192 if (!args) SWIG_fail;
8193 swig_obj[0] = args;
8194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8195 if (!SWIG_IsOK(res1)) {
8196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8197 }
8198 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8199 {
8200 PyThreadState* __tstate = wxPyBeginAllowThreads();
8201 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8202 wxPyEndAllowThreads(__tstate);
8203 if (PyErr_Occurred()) SWIG_fail;
8204 }
8205 resultobj = SWIG_From_double(static_cast< double >(result));
8206 return resultobj;
8207 fail:
8208 return NULL;
8209 }
8210
8211
8212 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8213 PyObject *resultobj = 0;
8214 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8215 double arg2 ;
8216 void *argp1 = 0 ;
8217 int res1 = 0 ;
8218 double val2 ;
8219 int ecode2 = 0 ;
8220 PyObject * obj0 = 0 ;
8221 PyObject * obj1 = 0 ;
8222 char * kwnames[] = {
8223 (char *) "self",(char *) "length", NULL
8224 };
8225
8226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8228 if (!SWIG_IsOK(res1)) {
8229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8230 }
8231 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8232 ecode2 = SWIG_AsVal_double(obj1, &val2);
8233 if (!SWIG_IsOK(ecode2)) {
8234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8235 }
8236 arg2 = static_cast< double >(val2);
8237 {
8238 PyThreadState* __tstate = wxPyBeginAllowThreads();
8239 (arg1)->SetVectorLength(arg2);
8240 wxPyEndAllowThreads(__tstate);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 resultobj = SWIG_Py_Void();
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8251 PyObject *resultobj = 0;
8252 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8253 double arg2 ;
8254 void *argp1 = 0 ;
8255 int res1 = 0 ;
8256 double val2 ;
8257 int ecode2 = 0 ;
8258 PyObject * obj0 = 0 ;
8259 PyObject * obj1 = 0 ;
8260 char * kwnames[] = {
8261 (char *) "self",(char *) "degrees", NULL
8262 };
8263
8264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8266 if (!SWIG_IsOK(res1)) {
8267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8268 }
8269 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8270 ecode2 = SWIG_AsVal_double(obj1, &val2);
8271 if (!SWIG_IsOK(ecode2)) {
8272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8273 }
8274 arg2 = static_cast< double >(val2);
8275 {
8276 PyThreadState* __tstate = wxPyBeginAllowThreads();
8277 (arg1)->SetVectorAngle(arg2);
8278 wxPyEndAllowThreads(__tstate);
8279 if (PyErr_Occurred()) SWIG_fail;
8280 }
8281 resultobj = SWIG_Py_Void();
8282 return resultobj;
8283 fail:
8284 return NULL;
8285 }
8286
8287
8288 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8289 PyObject *resultobj = 0;
8290 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8291 wxPoint2D *arg2 = 0 ;
8292 double result;
8293 void *argp1 = 0 ;
8294 int res1 = 0 ;
8295 wxPoint2D temp2 ;
8296 PyObject * obj0 = 0 ;
8297 PyObject * obj1 = 0 ;
8298 char * kwnames[] = {
8299 (char *) "self",(char *) "pt", NULL
8300 };
8301
8302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8304 if (!SWIG_IsOK(res1)) {
8305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8306 }
8307 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8308 {
8309 arg2 = &temp2;
8310 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8311 }
8312 {
8313 PyThreadState* __tstate = wxPyBeginAllowThreads();
8314 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8315 wxPyEndAllowThreads(__tstate);
8316 if (PyErr_Occurred()) SWIG_fail;
8317 }
8318 resultobj = SWIG_From_double(static_cast< double >(result));
8319 return resultobj;
8320 fail:
8321 return NULL;
8322 }
8323
8324
8325 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8326 PyObject *resultobj = 0;
8327 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8328 wxPoint2D *arg2 = 0 ;
8329 double result;
8330 void *argp1 = 0 ;
8331 int res1 = 0 ;
8332 wxPoint2D temp2 ;
8333 PyObject * obj0 = 0 ;
8334 PyObject * obj1 = 0 ;
8335 char * kwnames[] = {
8336 (char *) "self",(char *) "pt", NULL
8337 };
8338
8339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8343 }
8344 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8345 {
8346 arg2 = &temp2;
8347 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8348 }
8349 {
8350 PyThreadState* __tstate = wxPyBeginAllowThreads();
8351 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8352 wxPyEndAllowThreads(__tstate);
8353 if (PyErr_Occurred()) SWIG_fail;
8354 }
8355 resultobj = SWIG_From_double(static_cast< double >(result));
8356 return resultobj;
8357 fail:
8358 return NULL;
8359 }
8360
8361
8362 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8363 PyObject *resultobj = 0;
8364 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8365 wxPoint2D *arg2 = 0 ;
8366 double result;
8367 void *argp1 = 0 ;
8368 int res1 = 0 ;
8369 wxPoint2D temp2 ;
8370 PyObject * obj0 = 0 ;
8371 PyObject * obj1 = 0 ;
8372 char * kwnames[] = {
8373 (char *) "self",(char *) "vec", NULL
8374 };
8375
8376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8378 if (!SWIG_IsOK(res1)) {
8379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8380 }
8381 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8382 {
8383 arg2 = &temp2;
8384 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8385 }
8386 {
8387 PyThreadState* __tstate = wxPyBeginAllowThreads();
8388 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 resultobj = SWIG_From_double(static_cast< double >(result));
8393 return resultobj;
8394 fail:
8395 return NULL;
8396 }
8397
8398
8399 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8400 PyObject *resultobj = 0;
8401 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8402 wxPoint2D *arg2 = 0 ;
8403 double result;
8404 void *argp1 = 0 ;
8405 int res1 = 0 ;
8406 wxPoint2D temp2 ;
8407 PyObject * obj0 = 0 ;
8408 PyObject * obj1 = 0 ;
8409 char * kwnames[] = {
8410 (char *) "self",(char *) "vec", NULL
8411 };
8412
8413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8415 if (!SWIG_IsOK(res1)) {
8416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8417 }
8418 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8419 {
8420 arg2 = &temp2;
8421 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8422 }
8423 {
8424 PyThreadState* __tstate = wxPyBeginAllowThreads();
8425 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8426 wxPyEndAllowThreads(__tstate);
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 resultobj = SWIG_From_double(static_cast< double >(result));
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8437 PyObject *resultobj = 0;
8438 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8439 wxPoint2D result;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 PyObject *swig_obj[1] ;
8443
8444 if (!args) SWIG_fail;
8445 swig_obj[0] = args;
8446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8447 if (!SWIG_IsOK(res1)) {
8448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8449 }
8450 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8451 {
8452 PyThreadState* __tstate = wxPyBeginAllowThreads();
8453 result = (arg1)->operator -();
8454 wxPyEndAllowThreads(__tstate);
8455 if (PyErr_Occurred()) SWIG_fail;
8456 }
8457 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8458 return resultobj;
8459 fail:
8460 return NULL;
8461 }
8462
8463
8464 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8465 PyObject *resultobj = 0;
8466 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8467 wxPoint2D *arg2 = 0 ;
8468 wxPoint2D *result = 0 ;
8469 void *argp1 = 0 ;
8470 int res1 = 0 ;
8471 wxPoint2D temp2 ;
8472 PyObject * obj0 = 0 ;
8473 PyObject * obj1 = 0 ;
8474 char * kwnames[] = {
8475 (char *) "self",(char *) "pt", NULL
8476 };
8477
8478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8480 if (!SWIG_IsOK(res1)) {
8481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8482 }
8483 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8484 {
8485 arg2 = &temp2;
8486 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8487 }
8488 {
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 {
8491 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8492 result = (wxPoint2D *) &_result_ref;
8493 }
8494 wxPyEndAllowThreads(__tstate);
8495 if (PyErr_Occurred()) SWIG_fail;
8496 }
8497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8505 PyObject *resultobj = 0;
8506 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8507 wxPoint2D *arg2 = 0 ;
8508 wxPoint2D *result = 0 ;
8509 void *argp1 = 0 ;
8510 int res1 = 0 ;
8511 wxPoint2D temp2 ;
8512 PyObject * obj0 = 0 ;
8513 PyObject * obj1 = 0 ;
8514 char * kwnames[] = {
8515 (char *) "self",(char *) "pt", NULL
8516 };
8517
8518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8520 if (!SWIG_IsOK(res1)) {
8521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8522 }
8523 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8524 {
8525 arg2 = &temp2;
8526 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8527 }
8528 {
8529 PyThreadState* __tstate = wxPyBeginAllowThreads();
8530 {
8531 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8532 result = (wxPoint2D *) &_result_ref;
8533 }
8534 wxPyEndAllowThreads(__tstate);
8535 if (PyErr_Occurred()) SWIG_fail;
8536 }
8537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8538 return resultobj;
8539 fail:
8540 return NULL;
8541 }
8542
8543
8544 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8545 PyObject *resultobj = 0;
8546 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8547 wxPoint2D *arg2 = 0 ;
8548 wxPoint2D *result = 0 ;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 wxPoint2D temp2 ;
8552 PyObject * obj0 = 0 ;
8553 PyObject * obj1 = 0 ;
8554 char * kwnames[] = {
8555 (char *) "self",(char *) "pt", NULL
8556 };
8557
8558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8560 if (!SWIG_IsOK(res1)) {
8561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8562 }
8563 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8564 {
8565 arg2 = &temp2;
8566 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8567 }
8568 {
8569 PyThreadState* __tstate = wxPyBeginAllowThreads();
8570 {
8571 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8572 result = (wxPoint2D *) &_result_ref;
8573 }
8574 wxPyEndAllowThreads(__tstate);
8575 if (PyErr_Occurred()) SWIG_fail;
8576 }
8577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8578 return resultobj;
8579 fail:
8580 return NULL;
8581 }
8582
8583
8584 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8585 PyObject *resultobj = 0;
8586 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8587 wxPoint2D *arg2 = 0 ;
8588 wxPoint2D *result = 0 ;
8589 void *argp1 = 0 ;
8590 int res1 = 0 ;
8591 wxPoint2D temp2 ;
8592 PyObject * obj0 = 0 ;
8593 PyObject * obj1 = 0 ;
8594 char * kwnames[] = {
8595 (char *) "self",(char *) "pt", NULL
8596 };
8597
8598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8600 if (!SWIG_IsOK(res1)) {
8601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8602 }
8603 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8604 {
8605 arg2 = &temp2;
8606 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8607 }
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 {
8611 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8612 result = (wxPoint2D *) &_result_ref;
8613 }
8614 wxPyEndAllowThreads(__tstate);
8615 if (PyErr_Occurred()) SWIG_fail;
8616 }
8617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8618 return resultobj;
8619 fail:
8620 return NULL;
8621 }
8622
8623
8624 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8625 PyObject *resultobj = 0;
8626 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8627 PyObject *arg2 = (PyObject *) 0 ;
8628 bool result;
8629 void *argp1 = 0 ;
8630 int res1 = 0 ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 char * kwnames[] = {
8634 (char *) "self",(char *) "other", NULL
8635 };
8636
8637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8639 if (!SWIG_IsOK(res1)) {
8640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8641 }
8642 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8643 arg2 = obj1;
8644 {
8645 result = (bool)wxPoint2D___eq__(arg1,arg2);
8646 if (PyErr_Occurred()) SWIG_fail;
8647 }
8648 {
8649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8650 }
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj = 0;
8659 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8660 PyObject *arg2 = (PyObject *) 0 ;
8661 bool result;
8662 void *argp1 = 0 ;
8663 int res1 = 0 ;
8664 PyObject * obj0 = 0 ;
8665 PyObject * obj1 = 0 ;
8666 char * kwnames[] = {
8667 (char *) "self",(char *) "other", NULL
8668 };
8669
8670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8672 if (!SWIG_IsOK(res1)) {
8673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8674 }
8675 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8676 arg2 = obj1;
8677 {
8678 result = (bool)wxPoint2D___ne__(arg1,arg2);
8679 if (PyErr_Occurred()) SWIG_fail;
8680 }
8681 {
8682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8683 }
8684 return resultobj;
8685 fail:
8686 return NULL;
8687 }
8688
8689
8690 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8691 PyObject *resultobj = 0;
8692 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8693 double arg2 ;
8694 void *argp1 = 0 ;
8695 int res1 = 0 ;
8696 double val2 ;
8697 int ecode2 = 0 ;
8698 PyObject *swig_obj[2] ;
8699
8700 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8702 if (!SWIG_IsOK(res1)) {
8703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8704 }
8705 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8706 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8707 if (!SWIG_IsOK(ecode2)) {
8708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8709 }
8710 arg2 = static_cast< double >(val2);
8711 if (arg1) (arg1)->m_x = arg2;
8712
8713 resultobj = SWIG_Py_Void();
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8721 PyObject *resultobj = 0;
8722 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8723 double result;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 PyObject *swig_obj[1] ;
8727
8728 if (!args) SWIG_fail;
8729 swig_obj[0] = args;
8730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8731 if (!SWIG_IsOK(res1)) {
8732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8733 }
8734 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8735 result = (double) ((arg1)->m_x);
8736 resultobj = SWIG_From_double(static_cast< double >(result));
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8744 PyObject *resultobj = 0;
8745 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8746 double arg2 ;
8747 void *argp1 = 0 ;
8748 int res1 = 0 ;
8749 double val2 ;
8750 int ecode2 = 0 ;
8751 PyObject *swig_obj[2] ;
8752
8753 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8755 if (!SWIG_IsOK(res1)) {
8756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8757 }
8758 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8759 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8760 if (!SWIG_IsOK(ecode2)) {
8761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8762 }
8763 arg2 = static_cast< double >(val2);
8764 if (arg1) (arg1)->m_y = arg2;
8765
8766 resultobj = SWIG_Py_Void();
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8774 PyObject *resultobj = 0;
8775 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8776 double result;
8777 void *argp1 = 0 ;
8778 int res1 = 0 ;
8779 PyObject *swig_obj[1] ;
8780
8781 if (!args) SWIG_fail;
8782 swig_obj[0] = args;
8783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8784 if (!SWIG_IsOK(res1)) {
8785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8786 }
8787 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8788 result = (double) ((arg1)->m_y);
8789 resultobj = SWIG_From_double(static_cast< double >(result));
8790 return resultobj;
8791 fail:
8792 return NULL;
8793 }
8794
8795
8796 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8797 PyObject *resultobj = 0;
8798 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8799 double arg2 = (double) 0 ;
8800 double arg3 = (double) 0 ;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 double val2 ;
8804 int ecode2 = 0 ;
8805 double val3 ;
8806 int ecode3 = 0 ;
8807 PyObject * obj0 = 0 ;
8808 PyObject * obj1 = 0 ;
8809 PyObject * obj2 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "x",(char *) "y", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8816 if (!SWIG_IsOK(res1)) {
8817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8818 }
8819 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8820 if (obj1) {
8821 ecode2 = SWIG_AsVal_double(obj1, &val2);
8822 if (!SWIG_IsOK(ecode2)) {
8823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8824 }
8825 arg2 = static_cast< double >(val2);
8826 }
8827 if (obj2) {
8828 ecode3 = SWIG_AsVal_double(obj2, &val3);
8829 if (!SWIG_IsOK(ecode3)) {
8830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8831 }
8832 arg3 = static_cast< double >(val3);
8833 }
8834 {
8835 PyThreadState* __tstate = wxPyBeginAllowThreads();
8836 wxPoint2D_Set(arg1,arg2,arg3);
8837 wxPyEndAllowThreads(__tstate);
8838 if (PyErr_Occurred()) SWIG_fail;
8839 }
8840 resultobj = SWIG_Py_Void();
8841 return resultobj;
8842 fail:
8843 return NULL;
8844 }
8845
8846
8847 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8848 PyObject *resultobj = 0;
8849 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8850 PyObject *result = 0 ;
8851 void *argp1 = 0 ;
8852 int res1 = 0 ;
8853 PyObject *swig_obj[1] ;
8854
8855 if (!args) SWIG_fail;
8856 swig_obj[0] = args;
8857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8858 if (!SWIG_IsOK(res1)) {
8859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8860 }
8861 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 result = (PyObject *)wxPoint2D_Get(arg1);
8865 wxPyEndAllowThreads(__tstate);
8866 if (PyErr_Occurred()) SWIG_fail;
8867 }
8868 resultobj = result;
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8876 PyObject *obj;
8877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8878 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8879 return SWIG_Py_Void();
8880 }
8881
8882 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8883 return SWIG_Python_InitShadowInstance(args);
8884 }
8885
8886 SWIGINTERN int DefaultPosition_set(PyObject *) {
8887 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8888 return 1;
8889 }
8890
8891
8892 SWIGINTERN PyObject *DefaultPosition_get(void) {
8893 PyObject *pyobj = 0;
8894
8895 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8896 return pyobj;
8897 }
8898
8899
8900 SWIGINTERN int DefaultSize_set(PyObject *) {
8901 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8902 return 1;
8903 }
8904
8905
8906 SWIGINTERN PyObject *DefaultSize_get(void) {
8907 PyObject *pyobj = 0;
8908
8909 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8910 return pyobj;
8911 }
8912
8913
8914 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj = 0;
8916 PyObject *arg1 = (PyObject *) 0 ;
8917 wxPyInputStream *result = 0 ;
8918 PyObject * obj0 = 0 ;
8919 char * kwnames[] = {
8920 (char *) "p", NULL
8921 };
8922
8923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8924 arg1 = obj0;
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8932 return resultobj;
8933 fail:
8934 return NULL;
8935 }
8936
8937
8938 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8939 PyObject *resultobj = 0;
8940 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8941 void *argp1 = 0 ;
8942 int res1 = 0 ;
8943 PyObject *swig_obj[1] ;
8944
8945 if (!args) SWIG_fail;
8946 swig_obj[0] = args;
8947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8948 if (!SWIG_IsOK(res1)) {
8949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8950 }
8951 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 delete arg1;
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 resultobj = SWIG_Py_Void();
8960 return resultobj;
8961 fail:
8962 return NULL;
8963 }
8964
8965
8966 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8967 PyObject *resultobj = 0;
8968 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8969 void *argp1 = 0 ;
8970 int res1 = 0 ;
8971 PyObject *swig_obj[1] ;
8972
8973 if (!args) SWIG_fail;
8974 swig_obj[0] = args;
8975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8976 if (!SWIG_IsOK(res1)) {
8977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8978 }
8979 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8980 {
8981 PyThreadState* __tstate = wxPyBeginAllowThreads();
8982 (arg1)->close();
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 resultobj = SWIG_Py_Void();
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 PyObject *resultobj = 0;
8995 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8996 void *argp1 = 0 ;
8997 int res1 = 0 ;
8998 PyObject *swig_obj[1] ;
8999
9000 if (!args) SWIG_fail;
9001 swig_obj[0] = args;
9002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9003 if (!SWIG_IsOK(res1)) {
9004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9005 }
9006 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 (arg1)->flush();
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 resultobj = SWIG_Py_Void();
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9021 PyObject *resultobj = 0;
9022 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9023 bool result;
9024 void *argp1 = 0 ;
9025 int res1 = 0 ;
9026 PyObject *swig_obj[1] ;
9027
9028 if (!args) SWIG_fail;
9029 swig_obj[0] = args;
9030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9031 if (!SWIG_IsOK(res1)) {
9032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9033 }
9034 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9035 {
9036 PyThreadState* __tstate = wxPyBeginAllowThreads();
9037 result = (bool)(arg1)->eof();
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 {
9042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9043 }
9044 return resultobj;
9045 fail:
9046 return NULL;
9047 }
9048
9049
9050 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9051 PyObject *resultobj = 0;
9052 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9053 int arg2 = (int) -1 ;
9054 PyObject *result = 0 ;
9055 void *argp1 = 0 ;
9056 int res1 = 0 ;
9057 int val2 ;
9058 int ecode2 = 0 ;
9059 PyObject * obj0 = 0 ;
9060 PyObject * obj1 = 0 ;
9061 char * kwnames[] = {
9062 (char *) "self",(char *) "size", NULL
9063 };
9064
9065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9067 if (!SWIG_IsOK(res1)) {
9068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9069 }
9070 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9071 if (obj1) {
9072 ecode2 = SWIG_AsVal_int(obj1, &val2);
9073 if (!SWIG_IsOK(ecode2)) {
9074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9075 }
9076 arg2 = static_cast< int >(val2);
9077 }
9078 {
9079 PyThreadState* __tstate = wxPyBeginAllowThreads();
9080 result = (PyObject *)(arg1)->read(arg2);
9081 wxPyEndAllowThreads(__tstate);
9082 if (PyErr_Occurred()) SWIG_fail;
9083 }
9084 resultobj = result;
9085 return resultobj;
9086 fail:
9087 return NULL;
9088 }
9089
9090
9091 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9092 PyObject *resultobj = 0;
9093 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9094 int arg2 = (int) -1 ;
9095 PyObject *result = 0 ;
9096 void *argp1 = 0 ;
9097 int res1 = 0 ;
9098 int val2 ;
9099 int ecode2 = 0 ;
9100 PyObject * obj0 = 0 ;
9101 PyObject * obj1 = 0 ;
9102 char * kwnames[] = {
9103 (char *) "self",(char *) "size", NULL
9104 };
9105
9106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9108 if (!SWIG_IsOK(res1)) {
9109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9110 }
9111 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9112 if (obj1) {
9113 ecode2 = SWIG_AsVal_int(obj1, &val2);
9114 if (!SWIG_IsOK(ecode2)) {
9115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9116 }
9117 arg2 = static_cast< int >(val2);
9118 }
9119 {
9120 PyThreadState* __tstate = wxPyBeginAllowThreads();
9121 result = (PyObject *)(arg1)->readline(arg2);
9122 wxPyEndAllowThreads(__tstate);
9123 if (PyErr_Occurred()) SWIG_fail;
9124 }
9125 resultobj = result;
9126 return resultobj;
9127 fail:
9128 return NULL;
9129 }
9130
9131
9132 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9133 PyObject *resultobj = 0;
9134 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9135 int arg2 = (int) -1 ;
9136 PyObject *result = 0 ;
9137 void *argp1 = 0 ;
9138 int res1 = 0 ;
9139 int val2 ;
9140 int ecode2 = 0 ;
9141 PyObject * obj0 = 0 ;
9142 PyObject * obj1 = 0 ;
9143 char * kwnames[] = {
9144 (char *) "self",(char *) "sizehint", NULL
9145 };
9146
9147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9149 if (!SWIG_IsOK(res1)) {
9150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9151 }
9152 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9153 if (obj1) {
9154 ecode2 = SWIG_AsVal_int(obj1, &val2);
9155 if (!SWIG_IsOK(ecode2)) {
9156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9157 }
9158 arg2 = static_cast< int >(val2);
9159 }
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 result = (PyObject *)(arg1)->readlines(arg2);
9163 wxPyEndAllowThreads(__tstate);
9164 if (PyErr_Occurred()) SWIG_fail;
9165 }
9166 resultobj = result;
9167 return resultobj;
9168 fail:
9169 return NULL;
9170 }
9171
9172
9173 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9174 PyObject *resultobj = 0;
9175 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9176 int arg2 ;
9177 int arg3 = (int) 0 ;
9178 void *argp1 = 0 ;
9179 int res1 = 0 ;
9180 int val2 ;
9181 int ecode2 = 0 ;
9182 int val3 ;
9183 int ecode3 = 0 ;
9184 PyObject * obj0 = 0 ;
9185 PyObject * obj1 = 0 ;
9186 PyObject * obj2 = 0 ;
9187 char * kwnames[] = {
9188 (char *) "self",(char *) "offset",(char *) "whence", NULL
9189 };
9190
9191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9193 if (!SWIG_IsOK(res1)) {
9194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9195 }
9196 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9197 ecode2 = SWIG_AsVal_int(obj1, &val2);
9198 if (!SWIG_IsOK(ecode2)) {
9199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9200 }
9201 arg2 = static_cast< int >(val2);
9202 if (obj2) {
9203 ecode3 = SWIG_AsVal_int(obj2, &val3);
9204 if (!SWIG_IsOK(ecode3)) {
9205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9206 }
9207 arg3 = static_cast< int >(val3);
9208 }
9209 {
9210 PyThreadState* __tstate = wxPyBeginAllowThreads();
9211 (arg1)->seek(arg2,arg3);
9212 wxPyEndAllowThreads(__tstate);
9213 if (PyErr_Occurred()) SWIG_fail;
9214 }
9215 resultobj = SWIG_Py_Void();
9216 return resultobj;
9217 fail:
9218 return NULL;
9219 }
9220
9221
9222 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9223 PyObject *resultobj = 0;
9224 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9225 int result;
9226 void *argp1 = 0 ;
9227 int res1 = 0 ;
9228 PyObject *swig_obj[1] ;
9229
9230 if (!args) SWIG_fail;
9231 swig_obj[0] = args;
9232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9233 if (!SWIG_IsOK(res1)) {
9234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9235 }
9236 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 result = (int)(arg1)->tell();
9240 wxPyEndAllowThreads(__tstate);
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 resultobj = SWIG_From_int(static_cast< int >(result));
9244 return resultobj;
9245 fail:
9246 return NULL;
9247 }
9248
9249
9250 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9251 PyObject *resultobj = 0;
9252 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9253 char result;
9254 void *argp1 = 0 ;
9255 int res1 = 0 ;
9256 PyObject *swig_obj[1] ;
9257
9258 if (!args) SWIG_fail;
9259 swig_obj[0] = args;
9260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9261 if (!SWIG_IsOK(res1)) {
9262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9263 }
9264 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9265 {
9266 PyThreadState* __tstate = wxPyBeginAllowThreads();
9267 result = (char)(arg1)->Peek();
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 resultobj = SWIG_From_char(static_cast< char >(result));
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9279 PyObject *resultobj = 0;
9280 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9281 char result;
9282 void *argp1 = 0 ;
9283 int res1 = 0 ;
9284 PyObject *swig_obj[1] ;
9285
9286 if (!args) SWIG_fail;
9287 swig_obj[0] = args;
9288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9289 if (!SWIG_IsOK(res1)) {
9290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9291 }
9292 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9293 {
9294 PyThreadState* __tstate = wxPyBeginAllowThreads();
9295 result = (char)(arg1)->GetC();
9296 wxPyEndAllowThreads(__tstate);
9297 if (PyErr_Occurred()) SWIG_fail;
9298 }
9299 resultobj = SWIG_From_char(static_cast< char >(result));
9300 return resultobj;
9301 fail:
9302 return NULL;
9303 }
9304
9305
9306 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9307 PyObject *resultobj = 0;
9308 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9309 size_t result;
9310 void *argp1 = 0 ;
9311 int res1 = 0 ;
9312 PyObject *swig_obj[1] ;
9313
9314 if (!args) SWIG_fail;
9315 swig_obj[0] = args;
9316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9317 if (!SWIG_IsOK(res1)) {
9318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9319 }
9320 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9321 {
9322 PyThreadState* __tstate = wxPyBeginAllowThreads();
9323 result = (size_t)(arg1)->LastRead();
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9328 return resultobj;
9329 fail:
9330 return NULL;
9331 }
9332
9333
9334 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9335 PyObject *resultobj = 0;
9336 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9337 bool result;
9338 void *argp1 = 0 ;
9339 int res1 = 0 ;
9340 PyObject *swig_obj[1] ;
9341
9342 if (!args) SWIG_fail;
9343 swig_obj[0] = args;
9344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9345 if (!SWIG_IsOK(res1)) {
9346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9347 }
9348 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9349 {
9350 PyThreadState* __tstate = wxPyBeginAllowThreads();
9351 result = (bool)(arg1)->CanRead();
9352 wxPyEndAllowThreads(__tstate);
9353 if (PyErr_Occurred()) SWIG_fail;
9354 }
9355 {
9356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9357 }
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9365 PyObject *resultobj = 0;
9366 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9367 bool result;
9368 void *argp1 = 0 ;
9369 int res1 = 0 ;
9370 PyObject *swig_obj[1] ;
9371
9372 if (!args) SWIG_fail;
9373 swig_obj[0] = args;
9374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9375 if (!SWIG_IsOK(res1)) {
9376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9377 }
9378 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9379 {
9380 PyThreadState* __tstate = wxPyBeginAllowThreads();
9381 result = (bool)(arg1)->Eof();
9382 wxPyEndAllowThreads(__tstate);
9383 if (PyErr_Occurred()) SWIG_fail;
9384 }
9385 {
9386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9387 }
9388 return resultobj;
9389 fail:
9390 return NULL;
9391 }
9392
9393
9394 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9395 PyObject *resultobj = 0;
9396 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9397 char arg2 ;
9398 bool result;
9399 void *argp1 = 0 ;
9400 int res1 = 0 ;
9401 char val2 ;
9402 int ecode2 = 0 ;
9403 PyObject * obj0 = 0 ;
9404 PyObject * obj1 = 0 ;
9405 char * kwnames[] = {
9406 (char *) "self",(char *) "c", NULL
9407 };
9408
9409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9413 }
9414 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9415 ecode2 = SWIG_AsVal_char(obj1, &val2);
9416 if (!SWIG_IsOK(ecode2)) {
9417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9418 }
9419 arg2 = static_cast< char >(val2);
9420 {
9421 PyThreadState* __tstate = wxPyBeginAllowThreads();
9422 result = (bool)(arg1)->Ungetch(arg2);
9423 wxPyEndAllowThreads(__tstate);
9424 if (PyErr_Occurred()) SWIG_fail;
9425 }
9426 {
9427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9428 }
9429 return resultobj;
9430 fail:
9431 return NULL;
9432 }
9433
9434
9435 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9436 PyObject *resultobj = 0;
9437 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9438 long arg2 ;
9439 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9440 long result;
9441 void *argp1 = 0 ;
9442 int res1 = 0 ;
9443 long val2 ;
9444 int ecode2 = 0 ;
9445 int val3 ;
9446 int ecode3 = 0 ;
9447 PyObject * obj0 = 0 ;
9448 PyObject * obj1 = 0 ;
9449 PyObject * obj2 = 0 ;
9450 char * kwnames[] = {
9451 (char *) "self",(char *) "pos",(char *) "mode", NULL
9452 };
9453
9454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9456 if (!SWIG_IsOK(res1)) {
9457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9458 }
9459 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9460 ecode2 = SWIG_AsVal_long(obj1, &val2);
9461 if (!SWIG_IsOK(ecode2)) {
9462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9463 }
9464 arg2 = static_cast< long >(val2);
9465 if (obj2) {
9466 ecode3 = SWIG_AsVal_int(obj2, &val3);
9467 if (!SWIG_IsOK(ecode3)) {
9468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9469 }
9470 arg3 = static_cast< wxSeekMode >(val3);
9471 }
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (long)(arg1)->SeekI(arg2,arg3);
9475 wxPyEndAllowThreads(__tstate);
9476 if (PyErr_Occurred()) SWIG_fail;
9477 }
9478 resultobj = SWIG_From_long(static_cast< long >(result));
9479 return resultobj;
9480 fail:
9481 return NULL;
9482 }
9483
9484
9485 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9486 PyObject *resultobj = 0;
9487 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9488 long result;
9489 void *argp1 = 0 ;
9490 int res1 = 0 ;
9491 PyObject *swig_obj[1] ;
9492
9493 if (!args) SWIG_fail;
9494 swig_obj[0] = args;
9495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9496 if (!SWIG_IsOK(res1)) {
9497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9498 }
9499 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 result = (long)(arg1)->TellI();
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_From_long(static_cast< long >(result));
9507 return resultobj;
9508 fail:
9509 return NULL;
9510 }
9511
9512
9513 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9514 PyObject *obj;
9515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9516 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9517 return SWIG_Py_Void();
9518 }
9519
9520 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9521 return SWIG_Python_InitShadowInstance(args);
9522 }
9523
9524 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9525 PyObject *resultobj = 0;
9526 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9527 PyObject *arg2 = (PyObject *) 0 ;
9528 void *argp1 = 0 ;
9529 int res1 = 0 ;
9530 PyObject * obj0 = 0 ;
9531 PyObject * obj1 = 0 ;
9532 char * kwnames[] = {
9533 (char *) "self",(char *) "obj", NULL
9534 };
9535
9536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9538 if (!SWIG_IsOK(res1)) {
9539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9540 }
9541 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9542 arg2 = obj1;
9543 {
9544 PyThreadState* __tstate = wxPyBeginAllowThreads();
9545 wxOutputStream_write(arg1,arg2);
9546 wxPyEndAllowThreads(__tstate);
9547 if (PyErr_Occurred()) SWIG_fail;
9548 }
9549 resultobj = SWIG_Py_Void();
9550 return resultobj;
9551 fail:
9552 return NULL;
9553 }
9554
9555
9556 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9557 PyObject *resultobj = 0;
9558 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9559 size_t result;
9560 void *argp1 = 0 ;
9561 int res1 = 0 ;
9562 PyObject *swig_obj[1] ;
9563
9564 if (!args) SWIG_fail;
9565 swig_obj[0] = args;
9566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9567 if (!SWIG_IsOK(res1)) {
9568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9569 }
9570 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9578 return resultobj;
9579 fail:
9580 return NULL;
9581 }
9582
9583
9584 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9585 PyObject *obj;
9586 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9587 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9588 return SWIG_Py_Void();
9589 }
9590
9591 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9592 PyObject *resultobj = 0;
9593 wxInputStream *arg1 = (wxInputStream *) 0 ;
9594 wxString *arg2 = 0 ;
9595 wxString *arg3 = 0 ;
9596 wxString *arg4 = 0 ;
9597 wxDateTime arg5 ;
9598 wxFSFile *result = 0 ;
9599 wxPyInputStream *temp1 ;
9600 bool temp2 = false ;
9601 bool temp3 = false ;
9602 bool temp4 = false ;
9603 void *argp5 ;
9604 int res5 = 0 ;
9605 PyObject * obj0 = 0 ;
9606 PyObject * obj1 = 0 ;
9607 PyObject * obj2 = 0 ;
9608 PyObject * obj3 = 0 ;
9609 PyObject * obj4 = 0 ;
9610 char * kwnames[] = {
9611 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9612 };
9613
9614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9615 {
9616 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9617 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9618 } else {
9619 PyErr_Clear(); // clear the failure of the wxPyConvert above
9620 arg1 = wxPyCBInputStream_create(obj0, true);
9621 if (arg1 == NULL) {
9622 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9623 SWIG_fail;
9624 }
9625 }
9626 }
9627 {
9628 arg2 = wxString_in_helper(obj1);
9629 if (arg2 == NULL) SWIG_fail;
9630 temp2 = true;
9631 }
9632 {
9633 arg3 = wxString_in_helper(obj2);
9634 if (arg3 == NULL) SWIG_fail;
9635 temp3 = true;
9636 }
9637 {
9638 arg4 = wxString_in_helper(obj3);
9639 if (arg4 == NULL) SWIG_fail;
9640 temp4 = true;
9641 }
9642 {
9643 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9644 if (!SWIG_IsOK(res5)) {
9645 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9646 }
9647 if (!argp5) {
9648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9649 } else {
9650 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9651 arg5 = *temp;
9652 if (SWIG_IsNewObj(res5)) delete temp;
9653 }
9654 }
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9662 {
9663 if (temp2)
9664 delete arg2;
9665 }
9666 {
9667 if (temp3)
9668 delete arg3;
9669 }
9670 {
9671 if (temp4)
9672 delete arg4;
9673 }
9674 return resultobj;
9675 fail:
9676 {
9677 if (temp2)
9678 delete arg2;
9679 }
9680 {
9681 if (temp3)
9682 delete arg3;
9683 }
9684 {
9685 if (temp4)
9686 delete arg4;
9687 }
9688 return NULL;
9689 }
9690
9691
9692 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9693 PyObject *resultobj = 0;
9694 wxFSFile *arg1 = (wxFSFile *) 0 ;
9695 void *argp1 = 0 ;
9696 int res1 = 0 ;
9697 PyObject *swig_obj[1] ;
9698
9699 if (!args) SWIG_fail;
9700 swig_obj[0] = args;
9701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9702 if (!SWIG_IsOK(res1)) {
9703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9704 }
9705 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9706 {
9707 PyThreadState* __tstate = wxPyBeginAllowThreads();
9708 delete arg1;
9709
9710 wxPyEndAllowThreads(__tstate);
9711 if (PyErr_Occurred()) SWIG_fail;
9712 }
9713 resultobj = SWIG_Py_Void();
9714 return resultobj;
9715 fail:
9716 return NULL;
9717 }
9718
9719
9720 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9721 PyObject *resultobj = 0;
9722 wxFSFile *arg1 = (wxFSFile *) 0 ;
9723 wxInputStream *result = 0 ;
9724 void *argp1 = 0 ;
9725 int res1 = 0 ;
9726 PyObject *swig_obj[1] ;
9727
9728 if (!args) SWIG_fail;
9729 swig_obj[0] = args;
9730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9731 if (!SWIG_IsOK(res1)) {
9732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9733 }
9734 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 result = (wxInputStream *)(arg1)->GetStream();
9738 wxPyEndAllowThreads(__tstate);
9739 if (PyErr_Occurred()) SWIG_fail;
9740 }
9741 {
9742 wxPyInputStream * _ptr = NULL;
9743
9744 if (result) {
9745 _ptr = new wxPyInputStream(result);
9746 }
9747 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9748 }
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9756 PyObject *resultobj = 0;
9757 wxFSFile *arg1 = (wxFSFile *) 0 ;
9758 wxString *result = 0 ;
9759 void *argp1 = 0 ;
9760 int res1 = 0 ;
9761 PyObject *swig_obj[1] ;
9762
9763 if (!args) SWIG_fail;
9764 swig_obj[0] = args;
9765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9766 if (!SWIG_IsOK(res1)) {
9767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9768 }
9769 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 {
9773 wxString const &_result_ref = (arg1)->GetMimeType();
9774 result = (wxString *) &_result_ref;
9775 }
9776 wxPyEndAllowThreads(__tstate);
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 {
9780 #if wxUSE_UNICODE
9781 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9782 #else
9783 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9784 #endif
9785 }
9786 return resultobj;
9787 fail:
9788 return NULL;
9789 }
9790
9791
9792 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9793 PyObject *resultobj = 0;
9794 wxFSFile *arg1 = (wxFSFile *) 0 ;
9795 wxString *result = 0 ;
9796 void *argp1 = 0 ;
9797 int res1 = 0 ;
9798 PyObject *swig_obj[1] ;
9799
9800 if (!args) SWIG_fail;
9801 swig_obj[0] = args;
9802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9803 if (!SWIG_IsOK(res1)) {
9804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9805 }
9806 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 {
9810 wxString const &_result_ref = (arg1)->GetLocation();
9811 result = (wxString *) &_result_ref;
9812 }
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 {
9817 #if wxUSE_UNICODE
9818 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9819 #else
9820 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9821 #endif
9822 }
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 PyObject *resultobj = 0;
9831 wxFSFile *arg1 = (wxFSFile *) 0 ;
9832 wxString *result = 0 ;
9833 void *argp1 = 0 ;
9834 int res1 = 0 ;
9835 PyObject *swig_obj[1] ;
9836
9837 if (!args) SWIG_fail;
9838 swig_obj[0] = args;
9839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9840 if (!SWIG_IsOK(res1)) {
9841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9842 }
9843 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 {
9847 wxString const &_result_ref = (arg1)->GetAnchor();
9848 result = (wxString *) &_result_ref;
9849 }
9850 wxPyEndAllowThreads(__tstate);
9851 if (PyErr_Occurred()) SWIG_fail;
9852 }
9853 {
9854 #if wxUSE_UNICODE
9855 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9856 #else
9857 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9858 #endif
9859 }
9860 return resultobj;
9861 fail:
9862 return NULL;
9863 }
9864
9865
9866 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9867 PyObject *resultobj = 0;
9868 wxFSFile *arg1 = (wxFSFile *) 0 ;
9869 wxDateTime result;
9870 void *argp1 = 0 ;
9871 int res1 = 0 ;
9872 PyObject *swig_obj[1] ;
9873
9874 if (!args) SWIG_fail;
9875 swig_obj[0] = args;
9876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9877 if (!SWIG_IsOK(res1)) {
9878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9879 }
9880 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (arg1)->GetModificationTime();
9884 wxPyEndAllowThreads(__tstate);
9885 if (PyErr_Occurred()) SWIG_fail;
9886 }
9887 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9888 return resultobj;
9889 fail:
9890 return NULL;
9891 }
9892
9893
9894 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9895 PyObject *obj;
9896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9897 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9898 return SWIG_Py_Void();
9899 }
9900
9901 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 return SWIG_Python_InitShadowInstance(args);
9903 }
9904
9905 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9906 PyObject *resultobj = 0;
9907 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9908 void *argp1 = 0 ;
9909 int res1 = 0 ;
9910 PyObject *swig_obj[1] ;
9911
9912 if (!args) SWIG_fail;
9913 swig_obj[0] = args;
9914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9915 if (!SWIG_IsOK(res1)) {
9916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9917 }
9918 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9919 {
9920 PyThreadState* __tstate = wxPyBeginAllowThreads();
9921 delete arg1;
9922
9923 wxPyEndAllowThreads(__tstate);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 resultobj = SWIG_Py_Void();
9927 return resultobj;
9928 fail:
9929 return NULL;
9930 }
9931
9932
9933 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9934 PyObject *obj;
9935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9936 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9937 return SWIG_Py_Void();
9938 }
9939
9940 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9941 PyObject *resultobj = 0;
9942 wxPyFileSystemHandler *result = 0 ;
9943
9944 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9945 {
9946 PyThreadState* __tstate = wxPyBeginAllowThreads();
9947 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9948 wxPyEndAllowThreads(__tstate);
9949 if (PyErr_Occurred()) SWIG_fail;
9950 }
9951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9952 return resultobj;
9953 fail:
9954 return NULL;
9955 }
9956
9957
9958 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9959 PyObject *resultobj = 0;
9960 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9961 PyObject *arg2 = (PyObject *) 0 ;
9962 PyObject *arg3 = (PyObject *) 0 ;
9963 void *argp1 = 0 ;
9964 int res1 = 0 ;
9965 PyObject * obj0 = 0 ;
9966 PyObject * obj1 = 0 ;
9967 PyObject * obj2 = 0 ;
9968 char * kwnames[] = {
9969 (char *) "self",(char *) "self",(char *) "_class", NULL
9970 };
9971
9972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9974 if (!SWIG_IsOK(res1)) {
9975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9976 }
9977 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9978 arg2 = obj1;
9979 arg3 = obj2;
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 (arg1)->_setCallbackInfo(arg2,arg3);
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_Py_Void();
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9994 PyObject *resultobj = 0;
9995 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9996 wxString *arg2 = 0 ;
9997 bool result;
9998 void *argp1 = 0 ;
9999 int res1 = 0 ;
10000 bool temp2 = false ;
10001 PyObject * obj0 = 0 ;
10002 PyObject * obj1 = 0 ;
10003 char * kwnames[] = {
10004 (char *) "self",(char *) "location", NULL
10005 };
10006
10007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10009 if (!SWIG_IsOK(res1)) {
10010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10011 }
10012 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10013 {
10014 arg2 = wxString_in_helper(obj1);
10015 if (arg2 == NULL) SWIG_fail;
10016 temp2 = true;
10017 }
10018 {
10019 PyThreadState* __tstate = wxPyBeginAllowThreads();
10020 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10021 wxPyEndAllowThreads(__tstate);
10022 if (PyErr_Occurred()) SWIG_fail;
10023 }
10024 {
10025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10026 }
10027 {
10028 if (temp2)
10029 delete arg2;
10030 }
10031 return resultobj;
10032 fail:
10033 {
10034 if (temp2)
10035 delete arg2;
10036 }
10037 return NULL;
10038 }
10039
10040
10041 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10042 PyObject *resultobj = 0;
10043 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10044 wxFileSystem *arg2 = 0 ;
10045 wxString *arg3 = 0 ;
10046 wxFSFile *result = 0 ;
10047 void *argp1 = 0 ;
10048 int res1 = 0 ;
10049 void *argp2 = 0 ;
10050 int res2 = 0 ;
10051 bool temp3 = false ;
10052 PyObject * obj0 = 0 ;
10053 PyObject * obj1 = 0 ;
10054 PyObject * obj2 = 0 ;
10055 char * kwnames[] = {
10056 (char *) "self",(char *) "fs",(char *) "location", NULL
10057 };
10058
10059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10061 if (!SWIG_IsOK(res1)) {
10062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10063 }
10064 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10065 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10066 if (!SWIG_IsOK(res2)) {
10067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10068 }
10069 if (!argp2) {
10070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10071 }
10072 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10073 {
10074 arg3 = wxString_in_helper(obj2);
10075 if (arg3 == NULL) SWIG_fail;
10076 temp3 = true;
10077 }
10078 {
10079 PyThreadState* __tstate = wxPyBeginAllowThreads();
10080 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10081 wxPyEndAllowThreads(__tstate);
10082 if (PyErr_Occurred()) SWIG_fail;
10083 }
10084 {
10085 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10086 }
10087 {
10088 if (temp3)
10089 delete arg3;
10090 }
10091 return resultobj;
10092 fail:
10093 {
10094 if (temp3)
10095 delete arg3;
10096 }
10097 return NULL;
10098 }
10099
10100
10101 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10102 PyObject *resultobj = 0;
10103 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10104 wxString *arg2 = 0 ;
10105 int arg3 = (int) 0 ;
10106 wxString result;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 bool temp2 = false ;
10110 int val3 ;
10111 int ecode3 = 0 ;
10112 PyObject * obj0 = 0 ;
10113 PyObject * obj1 = 0 ;
10114 PyObject * obj2 = 0 ;
10115 char * kwnames[] = {
10116 (char *) "self",(char *) "spec",(char *) "flags", NULL
10117 };
10118
10119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10121 if (!SWIG_IsOK(res1)) {
10122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10123 }
10124 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10125 {
10126 arg2 = wxString_in_helper(obj1);
10127 if (arg2 == NULL) SWIG_fail;
10128 temp2 = true;
10129 }
10130 if (obj2) {
10131 ecode3 = SWIG_AsVal_int(obj2, &val3);
10132 if (!SWIG_IsOK(ecode3)) {
10133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10134 }
10135 arg3 = static_cast< int >(val3);
10136 }
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 {
10144 #if wxUSE_UNICODE
10145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10146 #else
10147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10148 #endif
10149 }
10150 {
10151 if (temp2)
10152 delete arg2;
10153 }
10154 return resultobj;
10155 fail:
10156 {
10157 if (temp2)
10158 delete arg2;
10159 }
10160 return NULL;
10161 }
10162
10163
10164 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10165 PyObject *resultobj = 0;
10166 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10167 wxString result;
10168 void *argp1 = 0 ;
10169 int res1 = 0 ;
10170 PyObject *swig_obj[1] ;
10171
10172 if (!args) SWIG_fail;
10173 swig_obj[0] = args;
10174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10175 if (!SWIG_IsOK(res1)) {
10176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10177 }
10178 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10179 {
10180 PyThreadState* __tstate = wxPyBeginAllowThreads();
10181 result = (arg1)->FindNext();
10182 wxPyEndAllowThreads(__tstate);
10183 if (PyErr_Occurred()) SWIG_fail;
10184 }
10185 {
10186 #if wxUSE_UNICODE
10187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10188 #else
10189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10190 #endif
10191 }
10192 return resultobj;
10193 fail:
10194 return NULL;
10195 }
10196
10197
10198 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10199 PyObject *resultobj = 0;
10200 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10201 wxString *arg2 = 0 ;
10202 wxString result;
10203 void *argp1 = 0 ;
10204 int res1 = 0 ;
10205 bool temp2 = false ;
10206 PyObject * obj0 = 0 ;
10207 PyObject * obj1 = 0 ;
10208 char * kwnames[] = {
10209 (char *) "self",(char *) "location", NULL
10210 };
10211
10212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10214 if (!SWIG_IsOK(res1)) {
10215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10216 }
10217 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10218 {
10219 arg2 = wxString_in_helper(obj1);
10220 if (arg2 == NULL) SWIG_fail;
10221 temp2 = true;
10222 }
10223 {
10224 PyThreadState* __tstate = wxPyBeginAllowThreads();
10225 result = (arg1)->GetProtocol((wxString const &)*arg2);
10226 wxPyEndAllowThreads(__tstate);
10227 if (PyErr_Occurred()) SWIG_fail;
10228 }
10229 {
10230 #if wxUSE_UNICODE
10231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10232 #else
10233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10234 #endif
10235 }
10236 {
10237 if (temp2)
10238 delete arg2;
10239 }
10240 return resultobj;
10241 fail:
10242 {
10243 if (temp2)
10244 delete arg2;
10245 }
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = 0;
10252 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10253 wxString *arg2 = 0 ;
10254 wxString result;
10255 void *argp1 = 0 ;
10256 int res1 = 0 ;
10257 bool temp2 = false ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char * kwnames[] = {
10261 (char *) "self",(char *) "location", NULL
10262 };
10263
10264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10268 }
10269 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10270 {
10271 arg2 = wxString_in_helper(obj1);
10272 if (arg2 == NULL) SWIG_fail;
10273 temp2 = true;
10274 }
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 {
10282 #if wxUSE_UNICODE
10283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10284 #else
10285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10286 #endif
10287 }
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return resultobj;
10293 fail:
10294 {
10295 if (temp2)
10296 delete arg2;
10297 }
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10305 wxString *arg2 = 0 ;
10306 wxString result;
10307 void *argp1 = 0 ;
10308 int res1 = 0 ;
10309 bool temp2 = false ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "location", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10320 }
10321 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10322 {
10323 arg2 = wxString_in_helper(obj1);
10324 if (arg2 == NULL) SWIG_fail;
10325 temp2 = true;
10326 }
10327 {
10328 PyThreadState* __tstate = wxPyBeginAllowThreads();
10329 result = (arg1)->GetAnchor((wxString const &)*arg2);
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 {
10334 #if wxUSE_UNICODE
10335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10336 #else
10337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10338 #endif
10339 }
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return resultobj;
10345 fail:
10346 {
10347 if (temp2)
10348 delete arg2;
10349 }
10350 return NULL;
10351 }
10352
10353
10354 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10355 PyObject *resultobj = 0;
10356 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10357 wxString *arg2 = 0 ;
10358 wxString result;
10359 void *argp1 = 0 ;
10360 int res1 = 0 ;
10361 bool temp2 = false ;
10362 PyObject * obj0 = 0 ;
10363 PyObject * obj1 = 0 ;
10364 char * kwnames[] = {
10365 (char *) "self",(char *) "location", NULL
10366 };
10367
10368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10370 if (!SWIG_IsOK(res1)) {
10371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10372 }
10373 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10374 {
10375 arg2 = wxString_in_helper(obj1);
10376 if (arg2 == NULL) SWIG_fail;
10377 temp2 = true;
10378 }
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 {
10386 #if wxUSE_UNICODE
10387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10388 #else
10389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10390 #endif
10391 }
10392 {
10393 if (temp2)
10394 delete arg2;
10395 }
10396 return resultobj;
10397 fail:
10398 {
10399 if (temp2)
10400 delete arg2;
10401 }
10402 return NULL;
10403 }
10404
10405
10406 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10407 PyObject *resultobj = 0;
10408 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10409 wxString *arg2 = 0 ;
10410 wxString result;
10411 void *argp1 = 0 ;
10412 int res1 = 0 ;
10413 bool temp2 = false ;
10414 PyObject * obj0 = 0 ;
10415 PyObject * obj1 = 0 ;
10416 char * kwnames[] = {
10417 (char *) "self",(char *) "location", NULL
10418 };
10419
10420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10422 if (!SWIG_IsOK(res1)) {
10423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10424 }
10425 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10426 {
10427 arg2 = wxString_in_helper(obj1);
10428 if (arg2 == NULL) SWIG_fail;
10429 temp2 = true;
10430 }
10431 {
10432 PyThreadState* __tstate = wxPyBeginAllowThreads();
10433 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10434 wxPyEndAllowThreads(__tstate);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 {
10438 #if wxUSE_UNICODE
10439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10440 #else
10441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10442 #endif
10443 }
10444 {
10445 if (temp2)
10446 delete arg2;
10447 }
10448 return resultobj;
10449 fail:
10450 {
10451 if (temp2)
10452 delete arg2;
10453 }
10454 return NULL;
10455 }
10456
10457
10458 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10459 PyObject *obj;
10460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10461 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10462 return SWIG_Py_Void();
10463 }
10464
10465 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10466 return SWIG_Python_InitShadowInstance(args);
10467 }
10468
10469 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10470 PyObject *resultobj = 0;
10471 wxFileSystem *result = 0 ;
10472
10473 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10474 {
10475 PyThreadState* __tstate = wxPyBeginAllowThreads();
10476 result = (wxFileSystem *)new wxFileSystem();
10477 wxPyEndAllowThreads(__tstate);
10478 if (PyErr_Occurred()) SWIG_fail;
10479 }
10480 {
10481 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10482 }
10483 return resultobj;
10484 fail:
10485 return NULL;
10486 }
10487
10488
10489 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10490 PyObject *resultobj = 0;
10491 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10492 void *argp1 = 0 ;
10493 int res1 = 0 ;
10494 PyObject *swig_obj[1] ;
10495
10496 if (!args) SWIG_fail;
10497 swig_obj[0] = args;
10498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10499 if (!SWIG_IsOK(res1)) {
10500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10501 }
10502 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10503 {
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 delete arg1;
10506
10507 wxPyEndAllowThreads(__tstate);
10508 if (PyErr_Occurred()) SWIG_fail;
10509 }
10510 resultobj = SWIG_Py_Void();
10511 return resultobj;
10512 fail:
10513 return NULL;
10514 }
10515
10516
10517 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10518 PyObject *resultobj = 0;
10519 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10520 wxString *arg2 = 0 ;
10521 bool arg3 = (bool) false ;
10522 void *argp1 = 0 ;
10523 int res1 = 0 ;
10524 bool temp2 = false ;
10525 bool val3 ;
10526 int ecode3 = 0 ;
10527 PyObject * obj0 = 0 ;
10528 PyObject * obj1 = 0 ;
10529 PyObject * obj2 = 0 ;
10530 char * kwnames[] = {
10531 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10532 };
10533
10534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10536 if (!SWIG_IsOK(res1)) {
10537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10538 }
10539 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10540 {
10541 arg2 = wxString_in_helper(obj1);
10542 if (arg2 == NULL) SWIG_fail;
10543 temp2 = true;
10544 }
10545 if (obj2) {
10546 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10547 if (!SWIG_IsOK(ecode3)) {
10548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10549 }
10550 arg3 = static_cast< bool >(val3);
10551 }
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10555 wxPyEndAllowThreads(__tstate);
10556 if (PyErr_Occurred()) SWIG_fail;
10557 }
10558 resultobj = SWIG_Py_Void();
10559 {
10560 if (temp2)
10561 delete arg2;
10562 }
10563 return resultobj;
10564 fail:
10565 {
10566 if (temp2)
10567 delete arg2;
10568 }
10569 return NULL;
10570 }
10571
10572
10573 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10574 PyObject *resultobj = 0;
10575 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10576 wxString result;
10577 void *argp1 = 0 ;
10578 int res1 = 0 ;
10579 PyObject *swig_obj[1] ;
10580
10581 if (!args) SWIG_fail;
10582 swig_obj[0] = args;
10583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10584 if (!SWIG_IsOK(res1)) {
10585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10586 }
10587 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10588 {
10589 PyThreadState* __tstate = wxPyBeginAllowThreads();
10590 result = (arg1)->GetPath();
10591 wxPyEndAllowThreads(__tstate);
10592 if (PyErr_Occurred()) SWIG_fail;
10593 }
10594 {
10595 #if wxUSE_UNICODE
10596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10597 #else
10598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10599 #endif
10600 }
10601 return resultobj;
10602 fail:
10603 return NULL;
10604 }
10605
10606
10607 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10608 PyObject *resultobj = 0;
10609 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10610 wxString *arg2 = 0 ;
10611 wxFSFile *result = 0 ;
10612 void *argp1 = 0 ;
10613 int res1 = 0 ;
10614 bool temp2 = false ;
10615 PyObject * obj0 = 0 ;
10616 PyObject * obj1 = 0 ;
10617 char * kwnames[] = {
10618 (char *) "self",(char *) "location", NULL
10619 };
10620
10621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10623 if (!SWIG_IsOK(res1)) {
10624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10625 }
10626 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10627 {
10628 arg2 = wxString_in_helper(obj1);
10629 if (arg2 == NULL) SWIG_fail;
10630 temp2 = true;
10631 }
10632 {
10633 PyThreadState* __tstate = wxPyBeginAllowThreads();
10634 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10635 wxPyEndAllowThreads(__tstate);
10636 if (PyErr_Occurred()) SWIG_fail;
10637 }
10638 {
10639 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10640 }
10641 {
10642 if (temp2)
10643 delete arg2;
10644 }
10645 return resultobj;
10646 fail:
10647 {
10648 if (temp2)
10649 delete arg2;
10650 }
10651 return NULL;
10652 }
10653
10654
10655 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10656 PyObject *resultobj = 0;
10657 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10658 wxString *arg2 = 0 ;
10659 int arg3 = (int) 0 ;
10660 wxString result;
10661 void *argp1 = 0 ;
10662 int res1 = 0 ;
10663 bool temp2 = false ;
10664 int val3 ;
10665 int ecode3 = 0 ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 PyObject * obj2 = 0 ;
10669 char * kwnames[] = {
10670 (char *) "self",(char *) "spec",(char *) "flags", NULL
10671 };
10672
10673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10675 if (!SWIG_IsOK(res1)) {
10676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10677 }
10678 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10679 {
10680 arg2 = wxString_in_helper(obj1);
10681 if (arg2 == NULL) SWIG_fail;
10682 temp2 = true;
10683 }
10684 if (obj2) {
10685 ecode3 = SWIG_AsVal_int(obj2, &val3);
10686 if (!SWIG_IsOK(ecode3)) {
10687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10688 }
10689 arg3 = static_cast< int >(val3);
10690 }
10691 {
10692 PyThreadState* __tstate = wxPyBeginAllowThreads();
10693 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10694 wxPyEndAllowThreads(__tstate);
10695 if (PyErr_Occurred()) SWIG_fail;
10696 }
10697 {
10698 #if wxUSE_UNICODE
10699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10700 #else
10701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10702 #endif
10703 }
10704 {
10705 if (temp2)
10706 delete arg2;
10707 }
10708 return resultobj;
10709 fail:
10710 {
10711 if (temp2)
10712 delete arg2;
10713 }
10714 return NULL;
10715 }
10716
10717
10718 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10719 PyObject *resultobj = 0;
10720 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10721 wxString result;
10722 void *argp1 = 0 ;
10723 int res1 = 0 ;
10724 PyObject *swig_obj[1] ;
10725
10726 if (!args) SWIG_fail;
10727 swig_obj[0] = args;
10728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10729 if (!SWIG_IsOK(res1)) {
10730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10731 }
10732 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10733 {
10734 PyThreadState* __tstate = wxPyBeginAllowThreads();
10735 result = (arg1)->FindNext();
10736 wxPyEndAllowThreads(__tstate);
10737 if (PyErr_Occurred()) SWIG_fail;
10738 }
10739 {
10740 #if wxUSE_UNICODE
10741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10742 #else
10743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10744 #endif
10745 }
10746 return resultobj;
10747 fail:
10748 return NULL;
10749 }
10750
10751
10752 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10753 PyObject *resultobj = 0;
10754 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10755 int res1 = 0 ;
10756 PyObject * obj0 = 0 ;
10757 char * kwnames[] = {
10758 (char *) "handler", NULL
10759 };
10760
10761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10762 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10763 if (!SWIG_IsOK(res1)) {
10764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10765 }
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 wxFileSystem::AddHandler(arg1);
10769 wxPyEndAllowThreads(__tstate);
10770 if (PyErr_Occurred()) SWIG_fail;
10771 }
10772 resultobj = SWIG_Py_Void();
10773 return resultobj;
10774 fail:
10775 return NULL;
10776 }
10777
10778
10779 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10780 PyObject *resultobj = 0;
10781
10782 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 wxFileSystem::CleanUpHandlers();
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 resultobj = SWIG_Py_Void();
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj = 0;
10798 wxString *arg1 = 0 ;
10799 wxString result;
10800 bool temp1 = false ;
10801 PyObject * obj0 = 0 ;
10802 char * kwnames[] = {
10803 (char *) "filename", NULL
10804 };
10805
10806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10807 {
10808 arg1 = wxString_in_helper(obj0);
10809 if (arg1 == NULL) SWIG_fail;
10810 temp1 = true;
10811 }
10812 {
10813 PyThreadState* __tstate = wxPyBeginAllowThreads();
10814 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10815 wxPyEndAllowThreads(__tstate);
10816 if (PyErr_Occurred()) SWIG_fail;
10817 }
10818 {
10819 #if wxUSE_UNICODE
10820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10821 #else
10822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10823 #endif
10824 }
10825 {
10826 if (temp1)
10827 delete arg1;
10828 }
10829 return resultobj;
10830 fail:
10831 {
10832 if (temp1)
10833 delete arg1;
10834 }
10835 return NULL;
10836 }
10837
10838
10839 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10840 PyObject *resultobj = 0;
10841 wxString *arg1 = 0 ;
10842 wxString result;
10843 bool temp1 = false ;
10844 PyObject * obj0 = 0 ;
10845 char * kwnames[] = {
10846 (char *) "url", NULL
10847 };
10848
10849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10850 {
10851 arg1 = wxString_in_helper(obj0);
10852 if (arg1 == NULL) SWIG_fail;
10853 temp1 = true;
10854 }
10855 {
10856 PyThreadState* __tstate = wxPyBeginAllowThreads();
10857 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
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 {
10869 if (temp1)
10870 delete arg1;
10871 }
10872 return resultobj;
10873 fail:
10874 {
10875 if (temp1)
10876 delete arg1;
10877 }
10878 return NULL;
10879 }
10880
10881
10882 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10883 PyObject *obj;
10884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10885 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10886 return SWIG_Py_Void();
10887 }
10888
10889 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890 return SWIG_Python_InitShadowInstance(args);
10891 }
10892
10893 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10894 PyObject *resultobj = 0;
10895 wxInternetFSHandler *result = 0 ;
10896
10897 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10898 {
10899 PyThreadState* __tstate = wxPyBeginAllowThreads();
10900 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10901 wxPyEndAllowThreads(__tstate);
10902 if (PyErr_Occurred()) SWIG_fail;
10903 }
10904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10905 return resultobj;
10906 fail:
10907 return NULL;
10908 }
10909
10910
10911 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10912 PyObject *resultobj = 0;
10913 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10914 wxString *arg2 = 0 ;
10915 bool result;
10916 void *argp1 = 0 ;
10917 int res1 = 0 ;
10918 bool temp2 = false ;
10919 PyObject * obj0 = 0 ;
10920 PyObject * obj1 = 0 ;
10921 char * kwnames[] = {
10922 (char *) "self",(char *) "location", NULL
10923 };
10924
10925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10927 if (!SWIG_IsOK(res1)) {
10928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10929 }
10930 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10931 {
10932 arg2 = wxString_in_helper(obj1);
10933 if (arg2 == NULL) SWIG_fail;
10934 temp2 = true;
10935 }
10936 {
10937 PyThreadState* __tstate = wxPyBeginAllowThreads();
10938 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10939 wxPyEndAllowThreads(__tstate);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 {
10943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10944 }
10945 {
10946 if (temp2)
10947 delete arg2;
10948 }
10949 return resultobj;
10950 fail:
10951 {
10952 if (temp2)
10953 delete arg2;
10954 }
10955 return NULL;
10956 }
10957
10958
10959 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10960 PyObject *resultobj = 0;
10961 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10962 wxFileSystem *arg2 = 0 ;
10963 wxString *arg3 = 0 ;
10964 wxFSFile *result = 0 ;
10965 void *argp1 = 0 ;
10966 int res1 = 0 ;
10967 void *argp2 = 0 ;
10968 int res2 = 0 ;
10969 bool temp3 = false ;
10970 PyObject * obj0 = 0 ;
10971 PyObject * obj1 = 0 ;
10972 PyObject * obj2 = 0 ;
10973 char * kwnames[] = {
10974 (char *) "self",(char *) "fs",(char *) "location", NULL
10975 };
10976
10977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10979 if (!SWIG_IsOK(res1)) {
10980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10981 }
10982 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10983 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10984 if (!SWIG_IsOK(res2)) {
10985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10986 }
10987 if (!argp2) {
10988 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10989 }
10990 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10991 {
10992 arg3 = wxString_in_helper(obj2);
10993 if (arg3 == NULL) SWIG_fail;
10994 temp3 = true;
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10999 wxPyEndAllowThreads(__tstate);
11000 if (PyErr_Occurred()) SWIG_fail;
11001 }
11002 {
11003 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11004 }
11005 {
11006 if (temp3)
11007 delete arg3;
11008 }
11009 return resultobj;
11010 fail:
11011 {
11012 if (temp3)
11013 delete arg3;
11014 }
11015 return NULL;
11016 }
11017
11018
11019 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11020 PyObject *obj;
11021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11022 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11023 return SWIG_Py_Void();
11024 }
11025
11026 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11027 return SWIG_Python_InitShadowInstance(args);
11028 }
11029
11030 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11031 PyObject *resultobj = 0;
11032 wxZipFSHandler *result = 0 ;
11033
11034 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 result = (wxZipFSHandler *)new wxZipFSHandler();
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11042 return resultobj;
11043 fail:
11044 return NULL;
11045 }
11046
11047
11048 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11049 PyObject *resultobj = 0;
11050 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11051 wxString *arg2 = 0 ;
11052 bool result;
11053 void *argp1 = 0 ;
11054 int res1 = 0 ;
11055 bool temp2 = false ;
11056 PyObject * obj0 = 0 ;
11057 PyObject * obj1 = 0 ;
11058 char * kwnames[] = {
11059 (char *) "self",(char *) "location", NULL
11060 };
11061
11062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11064 if (!SWIG_IsOK(res1)) {
11065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11066 }
11067 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11068 {
11069 arg2 = wxString_in_helper(obj1);
11070 if (arg2 == NULL) SWIG_fail;
11071 temp2 = true;
11072 }
11073 {
11074 PyThreadState* __tstate = wxPyBeginAllowThreads();
11075 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11076 wxPyEndAllowThreads(__tstate);
11077 if (PyErr_Occurred()) SWIG_fail;
11078 }
11079 {
11080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11081 }
11082 {
11083 if (temp2)
11084 delete arg2;
11085 }
11086 return resultobj;
11087 fail:
11088 {
11089 if (temp2)
11090 delete arg2;
11091 }
11092 return NULL;
11093 }
11094
11095
11096 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11097 PyObject *resultobj = 0;
11098 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11099 wxFileSystem *arg2 = 0 ;
11100 wxString *arg3 = 0 ;
11101 wxFSFile *result = 0 ;
11102 void *argp1 = 0 ;
11103 int res1 = 0 ;
11104 void *argp2 = 0 ;
11105 int res2 = 0 ;
11106 bool temp3 = false ;
11107 PyObject * obj0 = 0 ;
11108 PyObject * obj1 = 0 ;
11109 PyObject * obj2 = 0 ;
11110 char * kwnames[] = {
11111 (char *) "self",(char *) "fs",(char *) "location", NULL
11112 };
11113
11114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11116 if (!SWIG_IsOK(res1)) {
11117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11118 }
11119 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11120 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11121 if (!SWIG_IsOK(res2)) {
11122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11123 }
11124 if (!argp2) {
11125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11126 }
11127 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11128 {
11129 arg3 = wxString_in_helper(obj2);
11130 if (arg3 == NULL) SWIG_fail;
11131 temp3 = true;
11132 }
11133 {
11134 PyThreadState* __tstate = wxPyBeginAllowThreads();
11135 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11136 wxPyEndAllowThreads(__tstate);
11137 if (PyErr_Occurred()) SWIG_fail;
11138 }
11139 {
11140 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11141 }
11142 {
11143 if (temp3)
11144 delete arg3;
11145 }
11146 return resultobj;
11147 fail:
11148 {
11149 if (temp3)
11150 delete arg3;
11151 }
11152 return NULL;
11153 }
11154
11155
11156 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11157 PyObject *resultobj = 0;
11158 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11159 wxString *arg2 = 0 ;
11160 int arg3 = (int) 0 ;
11161 wxString result;
11162 void *argp1 = 0 ;
11163 int res1 = 0 ;
11164 bool temp2 = false ;
11165 int val3 ;
11166 int ecode3 = 0 ;
11167 PyObject * obj0 = 0 ;
11168 PyObject * obj1 = 0 ;
11169 PyObject * obj2 = 0 ;
11170 char * kwnames[] = {
11171 (char *) "self",(char *) "spec",(char *) "flags", NULL
11172 };
11173
11174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11176 if (!SWIG_IsOK(res1)) {
11177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11178 }
11179 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11180 {
11181 arg2 = wxString_in_helper(obj1);
11182 if (arg2 == NULL) SWIG_fail;
11183 temp2 = true;
11184 }
11185 if (obj2) {
11186 ecode3 = SWIG_AsVal_int(obj2, &val3);
11187 if (!SWIG_IsOK(ecode3)) {
11188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11189 }
11190 arg3 = static_cast< int >(val3);
11191 }
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 {
11199 #if wxUSE_UNICODE
11200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11201 #else
11202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11203 #endif
11204 }
11205 {
11206 if (temp2)
11207 delete arg2;
11208 }
11209 return resultobj;
11210 fail:
11211 {
11212 if (temp2)
11213 delete arg2;
11214 }
11215 return NULL;
11216 }
11217
11218
11219 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11220 PyObject *resultobj = 0;
11221 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11222 wxString result;
11223 void *argp1 = 0 ;
11224 int res1 = 0 ;
11225 PyObject *swig_obj[1] ;
11226
11227 if (!args) SWIG_fail;
11228 swig_obj[0] = args;
11229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11230 if (!SWIG_IsOK(res1)) {
11231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11232 }
11233 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11234 {
11235 PyThreadState* __tstate = wxPyBeginAllowThreads();
11236 result = (arg1)->FindNext();
11237 wxPyEndAllowThreads(__tstate);
11238 if (PyErr_Occurred()) SWIG_fail;
11239 }
11240 {
11241 #if wxUSE_UNICODE
11242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11243 #else
11244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11245 #endif
11246 }
11247 return resultobj;
11248 fail:
11249 return NULL;
11250 }
11251
11252
11253 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11254 PyObject *obj;
11255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11256 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11257 return SWIG_Py_Void();
11258 }
11259
11260 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11261 return SWIG_Python_InitShadowInstance(args);
11262 }
11263
11264 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11265 PyObject *resultobj = 0;
11266 wxString *arg1 = 0 ;
11267 wxImage *arg2 = 0 ;
11268 long arg3 ;
11269 bool temp1 = false ;
11270 void *argp2 = 0 ;
11271 int res2 = 0 ;
11272 long val3 ;
11273 int ecode3 = 0 ;
11274 PyObject * obj0 = 0 ;
11275 PyObject * obj1 = 0 ;
11276 PyObject * obj2 = 0 ;
11277 char * kwnames[] = {
11278 (char *) "filename",(char *) "image",(char *) "type", NULL
11279 };
11280
11281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11282 {
11283 arg1 = wxString_in_helper(obj0);
11284 if (arg1 == NULL) SWIG_fail;
11285 temp1 = true;
11286 }
11287 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11288 if (!SWIG_IsOK(res2)) {
11289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11290 }
11291 if (!argp2) {
11292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11293 }
11294 arg2 = reinterpret_cast< wxImage * >(argp2);
11295 ecode3 = SWIG_AsVal_long(obj2, &val3);
11296 if (!SWIG_IsOK(ecode3)) {
11297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11298 }
11299 arg3 = static_cast< long >(val3);
11300 {
11301 PyThreadState* __tstate = wxPyBeginAllowThreads();
11302 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 resultobj = SWIG_Py_Void();
11307 {
11308 if (temp1)
11309 delete arg1;
11310 }
11311 return resultobj;
11312 fail:
11313 {
11314 if (temp1)
11315 delete arg1;
11316 }
11317 return NULL;
11318 }
11319
11320
11321 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj = 0;
11323 wxString *arg1 = 0 ;
11324 wxBitmap *arg2 = 0 ;
11325 long arg3 ;
11326 bool temp1 = false ;
11327 void *argp2 = 0 ;
11328 int res2 = 0 ;
11329 long val3 ;
11330 int ecode3 = 0 ;
11331 PyObject * obj0 = 0 ;
11332 PyObject * obj1 = 0 ;
11333 PyObject * obj2 = 0 ;
11334 char * kwnames[] = {
11335 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11336 };
11337
11338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11339 {
11340 arg1 = wxString_in_helper(obj0);
11341 if (arg1 == NULL) SWIG_fail;
11342 temp1 = true;
11343 }
11344 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11345 if (!SWIG_IsOK(res2)) {
11346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11347 }
11348 if (!argp2) {
11349 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11350 }
11351 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11352 ecode3 = SWIG_AsVal_long(obj2, &val3);
11353 if (!SWIG_IsOK(ecode3)) {
11354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11355 }
11356 arg3 = static_cast< long >(val3);
11357 {
11358 PyThreadState* __tstate = wxPyBeginAllowThreads();
11359 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11360 wxPyEndAllowThreads(__tstate);
11361 if (PyErr_Occurred()) SWIG_fail;
11362 }
11363 resultobj = SWIG_Py_Void();
11364 {
11365 if (temp1)
11366 delete arg1;
11367 }
11368 return resultobj;
11369 fail:
11370 {
11371 if (temp1)
11372 delete arg1;
11373 }
11374 return NULL;
11375 }
11376
11377
11378 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj = 0;
11380 wxString *arg1 = 0 ;
11381 PyObject *arg2 = (PyObject *) 0 ;
11382 bool temp1 = false ;
11383 PyObject * obj0 = 0 ;
11384 PyObject * obj1 = 0 ;
11385 char * kwnames[] = {
11386 (char *) "filename",(char *) "data", NULL
11387 };
11388
11389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11390 {
11391 arg1 = wxString_in_helper(obj0);
11392 if (arg1 == NULL) SWIG_fail;
11393 temp1 = true;
11394 }
11395 arg2 = obj1;
11396 {
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 resultobj = SWIG_Py_Void();
11403 {
11404 if (temp1)
11405 delete arg1;
11406 }
11407 return resultobj;
11408 fail:
11409 {
11410 if (temp1)
11411 delete arg1;
11412 }
11413 return NULL;
11414 }
11415
11416
11417 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11418 PyObject *resultobj = 0;
11419 wxMemoryFSHandler *result = 0 ;
11420
11421 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11422 {
11423 PyThreadState* __tstate = wxPyBeginAllowThreads();
11424 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11425 wxPyEndAllowThreads(__tstate);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11429 return resultobj;
11430 fail:
11431 return NULL;
11432 }
11433
11434
11435 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11436 PyObject *resultobj = 0;
11437 wxString *arg1 = 0 ;
11438 bool temp1 = false ;
11439 PyObject * obj0 = 0 ;
11440 char * kwnames[] = {
11441 (char *) "filename", NULL
11442 };
11443
11444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11445 {
11446 arg1 = wxString_in_helper(obj0);
11447 if (arg1 == NULL) SWIG_fail;
11448 temp1 = true;
11449 }
11450 {
11451 PyThreadState* __tstate = wxPyBeginAllowThreads();
11452 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11453 wxPyEndAllowThreads(__tstate);
11454 if (PyErr_Occurred()) SWIG_fail;
11455 }
11456 resultobj = SWIG_Py_Void();
11457 {
11458 if (temp1)
11459 delete arg1;
11460 }
11461 return resultobj;
11462 fail:
11463 {
11464 if (temp1)
11465 delete arg1;
11466 }
11467 return NULL;
11468 }
11469
11470
11471 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj = 0;
11473 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11474 wxString *arg2 = 0 ;
11475 bool result;
11476 void *argp1 = 0 ;
11477 int res1 = 0 ;
11478 bool temp2 = false ;
11479 PyObject * obj0 = 0 ;
11480 PyObject * obj1 = 0 ;
11481 char * kwnames[] = {
11482 (char *) "self",(char *) "location", NULL
11483 };
11484
11485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11487 if (!SWIG_IsOK(res1)) {
11488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11489 }
11490 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11491 {
11492 arg2 = wxString_in_helper(obj1);
11493 if (arg2 == NULL) SWIG_fail;
11494 temp2 = true;
11495 }
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 {
11503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11504 }
11505 {
11506 if (temp2)
11507 delete arg2;
11508 }
11509 return resultobj;
11510 fail:
11511 {
11512 if (temp2)
11513 delete arg2;
11514 }
11515 return NULL;
11516 }
11517
11518
11519 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11520 PyObject *resultobj = 0;
11521 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11522 wxFileSystem *arg2 = 0 ;
11523 wxString *arg3 = 0 ;
11524 wxFSFile *result = 0 ;
11525 void *argp1 = 0 ;
11526 int res1 = 0 ;
11527 void *argp2 = 0 ;
11528 int res2 = 0 ;
11529 bool temp3 = false ;
11530 PyObject * obj0 = 0 ;
11531 PyObject * obj1 = 0 ;
11532 PyObject * obj2 = 0 ;
11533 char * kwnames[] = {
11534 (char *) "self",(char *) "fs",(char *) "location", NULL
11535 };
11536
11537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11539 if (!SWIG_IsOK(res1)) {
11540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11541 }
11542 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11543 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11544 if (!SWIG_IsOK(res2)) {
11545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11546 }
11547 if (!argp2) {
11548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11549 }
11550 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11551 {
11552 arg3 = wxString_in_helper(obj2);
11553 if (arg3 == NULL) SWIG_fail;
11554 temp3 = true;
11555 }
11556 {
11557 PyThreadState* __tstate = wxPyBeginAllowThreads();
11558 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11559 wxPyEndAllowThreads(__tstate);
11560 if (PyErr_Occurred()) SWIG_fail;
11561 }
11562 {
11563 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11564 }
11565 {
11566 if (temp3)
11567 delete arg3;
11568 }
11569 return resultobj;
11570 fail:
11571 {
11572 if (temp3)
11573 delete arg3;
11574 }
11575 return NULL;
11576 }
11577
11578
11579 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11580 PyObject *resultobj = 0;
11581 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11582 wxString *arg2 = 0 ;
11583 int arg3 = (int) 0 ;
11584 wxString result;
11585 void *argp1 = 0 ;
11586 int res1 = 0 ;
11587 bool temp2 = false ;
11588 int val3 ;
11589 int ecode3 = 0 ;
11590 PyObject * obj0 = 0 ;
11591 PyObject * obj1 = 0 ;
11592 PyObject * obj2 = 0 ;
11593 char * kwnames[] = {
11594 (char *) "self",(char *) "spec",(char *) "flags", NULL
11595 };
11596
11597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11599 if (!SWIG_IsOK(res1)) {
11600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11601 }
11602 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11603 {
11604 arg2 = wxString_in_helper(obj1);
11605 if (arg2 == NULL) SWIG_fail;
11606 temp2 = true;
11607 }
11608 if (obj2) {
11609 ecode3 = SWIG_AsVal_int(obj2, &val3);
11610 if (!SWIG_IsOK(ecode3)) {
11611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11612 }
11613 arg3 = static_cast< int >(val3);
11614 }
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11618 wxPyEndAllowThreads(__tstate);
11619 if (PyErr_Occurred()) SWIG_fail;
11620 }
11621 {
11622 #if wxUSE_UNICODE
11623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11624 #else
11625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11626 #endif
11627 }
11628 {
11629 if (temp2)
11630 delete arg2;
11631 }
11632 return resultobj;
11633 fail:
11634 {
11635 if (temp2)
11636 delete arg2;
11637 }
11638 return NULL;
11639 }
11640
11641
11642 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11643 PyObject *resultobj = 0;
11644 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11645 wxString result;
11646 void *argp1 = 0 ;
11647 int res1 = 0 ;
11648 PyObject *swig_obj[1] ;
11649
11650 if (!args) SWIG_fail;
11651 swig_obj[0] = args;
11652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11655 }
11656 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (arg1)->FindNext();
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 {
11664 #if wxUSE_UNICODE
11665 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11666 #else
11667 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11668 #endif
11669 }
11670 return resultobj;
11671 fail:
11672 return NULL;
11673 }
11674
11675
11676 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11677 PyObject *obj;
11678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11679 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11680 return SWIG_Py_Void();
11681 }
11682
11683 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11684 return SWIG_Python_InitShadowInstance(args);
11685 }
11686
11687 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11688 PyObject *resultobj = 0;
11689 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11690 wxString result;
11691 void *argp1 = 0 ;
11692 int res1 = 0 ;
11693 PyObject *swig_obj[1] ;
11694
11695 if (!args) SWIG_fail;
11696 swig_obj[0] = args;
11697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11698 if (!SWIG_IsOK(res1)) {
11699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11700 }
11701 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11702 {
11703 PyThreadState* __tstate = wxPyBeginAllowThreads();
11704 result = (arg1)->GetName();
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 {
11709 #if wxUSE_UNICODE
11710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11711 #else
11712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11713 #endif
11714 }
11715 return resultobj;
11716 fail:
11717 return NULL;
11718 }
11719
11720
11721 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11722 PyObject *resultobj = 0;
11723 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11724 wxString result;
11725 void *argp1 = 0 ;
11726 int res1 = 0 ;
11727 PyObject *swig_obj[1] ;
11728
11729 if (!args) SWIG_fail;
11730 swig_obj[0] = args;
11731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11732 if (!SWIG_IsOK(res1)) {
11733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11734 }
11735 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11736 {
11737 PyThreadState* __tstate = wxPyBeginAllowThreads();
11738 result = (arg1)->GetExtension();
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 {
11743 #if wxUSE_UNICODE
11744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11745 #else
11746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11747 #endif
11748 }
11749 return resultobj;
11750 fail:
11751 return NULL;
11752 }
11753
11754
11755 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11756 PyObject *resultobj = 0;
11757 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11758 long result;
11759 void *argp1 = 0 ;
11760 int res1 = 0 ;
11761 PyObject *swig_obj[1] ;
11762
11763 if (!args) SWIG_fail;
11764 swig_obj[0] = args;
11765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11768 }
11769 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11770 {
11771 PyThreadState* __tstate = wxPyBeginAllowThreads();
11772 result = (long)(arg1)->GetType();
11773 wxPyEndAllowThreads(__tstate);
11774 if (PyErr_Occurred()) SWIG_fail;
11775 }
11776 resultobj = SWIG_From_long(static_cast< long >(result));
11777 return resultobj;
11778 fail:
11779 return NULL;
11780 }
11781
11782
11783 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11784 PyObject *resultobj = 0;
11785 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11786 wxString result;
11787 void *argp1 = 0 ;
11788 int res1 = 0 ;
11789 PyObject *swig_obj[1] ;
11790
11791 if (!args) SWIG_fail;
11792 swig_obj[0] = args;
11793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11794 if (!SWIG_IsOK(res1)) {
11795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11796 }
11797 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 result = (arg1)->GetMimeType();
11801 wxPyEndAllowThreads(__tstate);
11802 if (PyErr_Occurred()) SWIG_fail;
11803 }
11804 {
11805 #if wxUSE_UNICODE
11806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11807 #else
11808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11809 #endif
11810 }
11811 return resultobj;
11812 fail:
11813 return NULL;
11814 }
11815
11816
11817 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11818 PyObject *resultobj = 0;
11819 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11820 wxString *arg2 = 0 ;
11821 bool result;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 bool temp2 = false ;
11825 PyObject * obj0 = 0 ;
11826 PyObject * obj1 = 0 ;
11827 char * kwnames[] = {
11828 (char *) "self",(char *) "name", NULL
11829 };
11830
11831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11833 if (!SWIG_IsOK(res1)) {
11834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11835 }
11836 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11837 {
11838 arg2 = wxString_in_helper(obj1);
11839 if (arg2 == NULL) SWIG_fail;
11840 temp2 = true;
11841 }
11842 {
11843 PyThreadState* __tstate = wxPyBeginAllowThreads();
11844 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11845 wxPyEndAllowThreads(__tstate);
11846 if (PyErr_Occurred()) SWIG_fail;
11847 }
11848 {
11849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11850 }
11851 {
11852 if (temp2)
11853 delete arg2;
11854 }
11855 return resultobj;
11856 fail:
11857 {
11858 if (temp2)
11859 delete arg2;
11860 }
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11866 PyObject *resultobj = 0;
11867 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11868 wxString *arg2 = 0 ;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 bool temp2 = false ;
11872 PyObject * obj0 = 0 ;
11873 PyObject * obj1 = 0 ;
11874 char * kwnames[] = {
11875 (char *) "self",(char *) "name", NULL
11876 };
11877
11878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11880 if (!SWIG_IsOK(res1)) {
11881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11882 }
11883 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11884 {
11885 arg2 = wxString_in_helper(obj1);
11886 if (arg2 == NULL) SWIG_fail;
11887 temp2 = true;
11888 }
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 (arg1)->SetName((wxString const &)*arg2);
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 resultobj = SWIG_Py_Void();
11896 {
11897 if (temp2)
11898 delete arg2;
11899 }
11900 return resultobj;
11901 fail:
11902 {
11903 if (temp2)
11904 delete arg2;
11905 }
11906 return NULL;
11907 }
11908
11909
11910 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11911 PyObject *resultobj = 0;
11912 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11913 wxString *arg2 = 0 ;
11914 void *argp1 = 0 ;
11915 int res1 = 0 ;
11916 bool temp2 = false ;
11917 PyObject * obj0 = 0 ;
11918 PyObject * obj1 = 0 ;
11919 char * kwnames[] = {
11920 (char *) "self",(char *) "extension", NULL
11921 };
11922
11923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11925 if (!SWIG_IsOK(res1)) {
11926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11927 }
11928 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11929 {
11930 arg2 = wxString_in_helper(obj1);
11931 if (arg2 == NULL) SWIG_fail;
11932 temp2 = true;
11933 }
11934 {
11935 PyThreadState* __tstate = wxPyBeginAllowThreads();
11936 (arg1)->SetExtension((wxString const &)*arg2);
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 resultobj = SWIG_Py_Void();
11941 {
11942 if (temp2)
11943 delete arg2;
11944 }
11945 return resultobj;
11946 fail:
11947 {
11948 if (temp2)
11949 delete arg2;
11950 }
11951 return NULL;
11952 }
11953
11954
11955 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11956 PyObject *resultobj = 0;
11957 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11958 long arg2 ;
11959 void *argp1 = 0 ;
11960 int res1 = 0 ;
11961 long val2 ;
11962 int ecode2 = 0 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 char * kwnames[] = {
11966 (char *) "self",(char *) "type", NULL
11967 };
11968
11969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11971 if (!SWIG_IsOK(res1)) {
11972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11973 }
11974 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11975 ecode2 = SWIG_AsVal_long(obj1, &val2);
11976 if (!SWIG_IsOK(ecode2)) {
11977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11978 }
11979 arg2 = static_cast< long >(val2);
11980 {
11981 PyThreadState* __tstate = wxPyBeginAllowThreads();
11982 (arg1)->SetType(arg2);
11983 wxPyEndAllowThreads(__tstate);
11984 if (PyErr_Occurred()) SWIG_fail;
11985 }
11986 resultobj = SWIG_Py_Void();
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj = 0;
11995 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11996 wxString *arg2 = 0 ;
11997 void *argp1 = 0 ;
11998 int res1 = 0 ;
11999 bool temp2 = false ;
12000 PyObject * obj0 = 0 ;
12001 PyObject * obj1 = 0 ;
12002 char * kwnames[] = {
12003 (char *) "self",(char *) "mimetype", NULL
12004 };
12005
12006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12008 if (!SWIG_IsOK(res1)) {
12009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12010 }
12011 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12012 {
12013 arg2 = wxString_in_helper(obj1);
12014 if (arg2 == NULL) SWIG_fail;
12015 temp2 = true;
12016 }
12017 {
12018 PyThreadState* __tstate = wxPyBeginAllowThreads();
12019 (arg1)->SetMimeType((wxString const &)*arg2);
12020 wxPyEndAllowThreads(__tstate);
12021 if (PyErr_Occurred()) SWIG_fail;
12022 }
12023 resultobj = SWIG_Py_Void();
12024 {
12025 if (temp2)
12026 delete arg2;
12027 }
12028 return resultobj;
12029 fail:
12030 {
12031 if (temp2)
12032 delete arg2;
12033 }
12034 return NULL;
12035 }
12036
12037
12038 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12039 PyObject *obj;
12040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12041 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12042 return SWIG_Py_Void();
12043 }
12044
12045 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12046 PyObject *resultobj = 0;
12047 wxPyImageHandler *result = 0 ;
12048
12049 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12050 {
12051 PyThreadState* __tstate = wxPyBeginAllowThreads();
12052 result = (wxPyImageHandler *)new wxPyImageHandler();
12053 wxPyEndAllowThreads(__tstate);
12054 if (PyErr_Occurred()) SWIG_fail;
12055 }
12056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12057 return resultobj;
12058 fail:
12059 return NULL;
12060 }
12061
12062
12063 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12064 PyObject *resultobj = 0;
12065 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12066 PyObject *arg2 = (PyObject *) 0 ;
12067 void *argp1 = 0 ;
12068 int res1 = 0 ;
12069 PyObject * obj0 = 0 ;
12070 PyObject * obj1 = 0 ;
12071 char * kwnames[] = {
12072 (char *) "self",(char *) "self", NULL
12073 };
12074
12075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12077 if (!SWIG_IsOK(res1)) {
12078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12079 }
12080 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12081 arg2 = obj1;
12082 {
12083 PyThreadState* __tstate = wxPyBeginAllowThreads();
12084 (arg1)->_SetSelf(arg2);
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 resultobj = SWIG_Py_Void();
12089 return resultobj;
12090 fail:
12091 return NULL;
12092 }
12093
12094
12095 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12096 PyObject *obj;
12097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12098 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12099 return SWIG_Py_Void();
12100 }
12101
12102 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12103 return SWIG_Python_InitShadowInstance(args);
12104 }
12105
12106 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12107 PyObject *resultobj = 0;
12108 wxImageHistogram *result = 0 ;
12109
12110 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12111 {
12112 PyThreadState* __tstate = wxPyBeginAllowThreads();
12113 result = (wxImageHistogram *)new wxImageHistogram();
12114 wxPyEndAllowThreads(__tstate);
12115 if (PyErr_Occurred()) SWIG_fail;
12116 }
12117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12125 PyObject *resultobj = 0;
12126 byte arg1 ;
12127 byte arg2 ;
12128 byte arg3 ;
12129 unsigned long result;
12130 unsigned char val1 ;
12131 int ecode1 = 0 ;
12132 unsigned char val2 ;
12133 int ecode2 = 0 ;
12134 unsigned char val3 ;
12135 int ecode3 = 0 ;
12136 PyObject * obj0 = 0 ;
12137 PyObject * obj1 = 0 ;
12138 PyObject * obj2 = 0 ;
12139 char * kwnames[] = {
12140 (char *) "r",(char *) "g",(char *) "b", NULL
12141 };
12142
12143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12144 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12145 if (!SWIG_IsOK(ecode1)) {
12146 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12147 }
12148 arg1 = static_cast< byte >(val1);
12149 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12150 if (!SWIG_IsOK(ecode2)) {
12151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12152 }
12153 arg2 = static_cast< byte >(val2);
12154 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12155 if (!SWIG_IsOK(ecode3)) {
12156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12157 }
12158 arg3 = static_cast< byte >(val3);
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12173 PyObject *resultobj = 0;
12174 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12175 byte *arg2 = (byte *) 0 ;
12176 byte *arg3 = (byte *) 0 ;
12177 byte *arg4 = (byte *) 0 ;
12178 byte arg5 = (byte) 1 ;
12179 byte arg6 = (byte) 0 ;
12180 byte arg7 = (byte) 0 ;
12181 bool result;
12182 void *argp1 = 0 ;
12183 int res1 = 0 ;
12184 byte temp2 ;
12185 int res2 = SWIG_TMPOBJ ;
12186 byte temp3 ;
12187 int res3 = SWIG_TMPOBJ ;
12188 byte temp4 ;
12189 int res4 = SWIG_TMPOBJ ;
12190 unsigned char val5 ;
12191 int ecode5 = 0 ;
12192 unsigned char val6 ;
12193 int ecode6 = 0 ;
12194 unsigned char val7 ;
12195 int ecode7 = 0 ;
12196 PyObject * obj0 = 0 ;
12197 PyObject * obj1 = 0 ;
12198 PyObject * obj2 = 0 ;
12199 PyObject * obj3 = 0 ;
12200 char * kwnames[] = {
12201 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12202 };
12203
12204 arg2 = &temp2;
12205 arg3 = &temp3;
12206 arg4 = &temp4;
12207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12209 if (!SWIG_IsOK(res1)) {
12210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12211 }
12212 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12213 if (obj1) {
12214 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12215 if (!SWIG_IsOK(ecode5)) {
12216 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12217 }
12218 arg5 = static_cast< byte >(val5);
12219 }
12220 if (obj2) {
12221 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12222 if (!SWIG_IsOK(ecode6)) {
12223 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12224 }
12225 arg6 = static_cast< byte >(val6);
12226 }
12227 if (obj3) {
12228 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12229 if (!SWIG_IsOK(ecode7)) {
12230 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12231 }
12232 arg7 = static_cast< byte >(val7);
12233 }
12234 {
12235 PyThreadState* __tstate = wxPyBeginAllowThreads();
12236 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12237 wxPyEndAllowThreads(__tstate);
12238 if (PyErr_Occurred()) SWIG_fail;
12239 }
12240 {
12241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12242 }
12243 if (SWIG_IsTmpObj(res2)) {
12244 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12245 } else {
12246 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12248 }
12249 if (SWIG_IsTmpObj(res3)) {
12250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12251 } else {
12252 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12254 }
12255 if (SWIG_IsTmpObj(res4)) {
12256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12257 } else {
12258 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12260 }
12261 return resultobj;
12262 fail:
12263 return NULL;
12264 }
12265
12266
12267 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12268 PyObject *resultobj = 0;
12269 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12270 unsigned long arg2 ;
12271 unsigned long result;
12272 void *argp1 = 0 ;
12273 int res1 = 0 ;
12274 unsigned long val2 ;
12275 int ecode2 = 0 ;
12276 PyObject * obj0 = 0 ;
12277 PyObject * obj1 = 0 ;
12278 char * kwnames[] = {
12279 (char *) "self",(char *) "key", NULL
12280 };
12281
12282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12284 if (!SWIG_IsOK(res1)) {
12285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12286 }
12287 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12288 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12289 if (!SWIG_IsOK(ecode2)) {
12290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12291 }
12292 arg2 = static_cast< unsigned long >(val2);
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12300 return resultobj;
12301 fail:
12302 return NULL;
12303 }
12304
12305
12306 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12307 PyObject *resultobj = 0;
12308 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12309 byte arg2 ;
12310 byte arg3 ;
12311 byte arg4 ;
12312 unsigned long result;
12313 void *argp1 = 0 ;
12314 int res1 = 0 ;
12315 unsigned char val2 ;
12316 int ecode2 = 0 ;
12317 unsigned char val3 ;
12318 int ecode3 = 0 ;
12319 unsigned char val4 ;
12320 int ecode4 = 0 ;
12321 PyObject * obj0 = 0 ;
12322 PyObject * obj1 = 0 ;
12323 PyObject * obj2 = 0 ;
12324 PyObject * obj3 = 0 ;
12325 char * kwnames[] = {
12326 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12327 };
12328
12329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12331 if (!SWIG_IsOK(res1)) {
12332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12333 }
12334 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12335 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12336 if (!SWIG_IsOK(ecode2)) {
12337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12338 }
12339 arg2 = static_cast< byte >(val2);
12340 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12341 if (!SWIG_IsOK(ecode3)) {
12342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12343 }
12344 arg3 = static_cast< byte >(val3);
12345 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12346 if (!SWIG_IsOK(ecode4)) {
12347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12348 }
12349 arg4 = static_cast< byte >(val4);
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12353 wxPyEndAllowThreads(__tstate);
12354 if (PyErr_Occurred()) SWIG_fail;
12355 }
12356 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12357 return resultobj;
12358 fail:
12359 return NULL;
12360 }
12361
12362
12363 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12364 PyObject *resultobj = 0;
12365 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12366 wxColour *arg2 = 0 ;
12367 unsigned long result;
12368 void *argp1 = 0 ;
12369 int res1 = 0 ;
12370 wxColour temp2 ;
12371 PyObject * obj0 = 0 ;
12372 PyObject * obj1 = 0 ;
12373 char * kwnames[] = {
12374 (char *) "self",(char *) "colour", NULL
12375 };
12376
12377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12379 if (!SWIG_IsOK(res1)) {
12380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12381 }
12382 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12383 {
12384 arg2 = &temp2;
12385 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12386 }
12387 {
12388 PyThreadState* __tstate = wxPyBeginAllowThreads();
12389 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12394 return resultobj;
12395 fail:
12396 return NULL;
12397 }
12398
12399
12400 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12401 PyObject *obj;
12402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12403 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12404 return SWIG_Py_Void();
12405 }
12406
12407 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12408 return SWIG_Python_InitShadowInstance(args);
12409 }
12410
12411 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12412 PyObject *resultobj = 0;
12413 byte arg1 = (byte) 0 ;
12414 byte arg2 = (byte) 0 ;
12415 byte arg3 = (byte) 0 ;
12416 wxImage_RGBValue *result = 0 ;
12417 unsigned char val1 ;
12418 int ecode1 = 0 ;
12419 unsigned char val2 ;
12420 int ecode2 = 0 ;
12421 unsigned char val3 ;
12422 int ecode3 = 0 ;
12423 PyObject * obj0 = 0 ;
12424 PyObject * obj1 = 0 ;
12425 PyObject * obj2 = 0 ;
12426 char * kwnames[] = {
12427 (char *) "r",(char *) "g",(char *) "b", NULL
12428 };
12429
12430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12431 if (obj0) {
12432 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12433 if (!SWIG_IsOK(ecode1)) {
12434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12435 }
12436 arg1 = static_cast< byte >(val1);
12437 }
12438 if (obj1) {
12439 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12440 if (!SWIG_IsOK(ecode2)) {
12441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12442 }
12443 arg2 = static_cast< byte >(val2);
12444 }
12445 if (obj2) {
12446 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12447 if (!SWIG_IsOK(ecode3)) {
12448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12449 }
12450 arg3 = static_cast< byte >(val3);
12451 }
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12459 return resultobj;
12460 fail:
12461 return NULL;
12462 }
12463
12464
12465 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12466 PyObject *resultobj = 0;
12467 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12468 byte arg2 ;
12469 void *argp1 = 0 ;
12470 int res1 = 0 ;
12471 unsigned char val2 ;
12472 int ecode2 = 0 ;
12473 PyObject *swig_obj[2] ;
12474
12475 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12477 if (!SWIG_IsOK(res1)) {
12478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12479 }
12480 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12481 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12482 if (!SWIG_IsOK(ecode2)) {
12483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12484 }
12485 arg2 = static_cast< byte >(val2);
12486 if (arg1) (arg1)->red = arg2;
12487
12488 resultobj = SWIG_Py_Void();
12489 return resultobj;
12490 fail:
12491 return NULL;
12492 }
12493
12494
12495 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496 PyObject *resultobj = 0;
12497 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12498 byte result;
12499 void *argp1 = 0 ;
12500 int res1 = 0 ;
12501 PyObject *swig_obj[1] ;
12502
12503 if (!args) SWIG_fail;
12504 swig_obj[0] = args;
12505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12506 if (!SWIG_IsOK(res1)) {
12507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12508 }
12509 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12510 result = (byte) ((arg1)->red);
12511 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12512 return resultobj;
12513 fail:
12514 return NULL;
12515 }
12516
12517
12518 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12519 PyObject *resultobj = 0;
12520 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12521 byte arg2 ;
12522 void *argp1 = 0 ;
12523 int res1 = 0 ;
12524 unsigned char val2 ;
12525 int ecode2 = 0 ;
12526 PyObject *swig_obj[2] ;
12527
12528 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12530 if (!SWIG_IsOK(res1)) {
12531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12532 }
12533 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12534 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12535 if (!SWIG_IsOK(ecode2)) {
12536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12537 }
12538 arg2 = static_cast< byte >(val2);
12539 if (arg1) (arg1)->green = arg2;
12540
12541 resultobj = SWIG_Py_Void();
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12549 PyObject *resultobj = 0;
12550 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12551 byte result;
12552 void *argp1 = 0 ;
12553 int res1 = 0 ;
12554 PyObject *swig_obj[1] ;
12555
12556 if (!args) SWIG_fail;
12557 swig_obj[0] = args;
12558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12559 if (!SWIG_IsOK(res1)) {
12560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12561 }
12562 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12563 result = (byte) ((arg1)->green);
12564 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12565 return resultobj;
12566 fail:
12567 return NULL;
12568 }
12569
12570
12571 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12572 PyObject *resultobj = 0;
12573 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12574 byte arg2 ;
12575 void *argp1 = 0 ;
12576 int res1 = 0 ;
12577 unsigned char val2 ;
12578 int ecode2 = 0 ;
12579 PyObject *swig_obj[2] ;
12580
12581 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12583 if (!SWIG_IsOK(res1)) {
12584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12585 }
12586 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12587 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12588 if (!SWIG_IsOK(ecode2)) {
12589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12590 }
12591 arg2 = static_cast< byte >(val2);
12592 if (arg1) (arg1)->blue = arg2;
12593
12594 resultobj = SWIG_Py_Void();
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12602 PyObject *resultobj = 0;
12603 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12604 byte result;
12605 void *argp1 = 0 ;
12606 int res1 = 0 ;
12607 PyObject *swig_obj[1] ;
12608
12609 if (!args) SWIG_fail;
12610 swig_obj[0] = args;
12611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12612 if (!SWIG_IsOK(res1)) {
12613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12614 }
12615 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12616 result = (byte) ((arg1)->blue);
12617 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12625 PyObject *obj;
12626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12627 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12628 return SWIG_Py_Void();
12629 }
12630
12631 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12632 return SWIG_Python_InitShadowInstance(args);
12633 }
12634
12635 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12636 PyObject *resultobj = 0;
12637 double arg1 = (double) 0.0 ;
12638 double arg2 = (double) 0.0 ;
12639 double arg3 = (double) 0.0 ;
12640 wxImage_HSVValue *result = 0 ;
12641 double val1 ;
12642 int ecode1 = 0 ;
12643 double val2 ;
12644 int ecode2 = 0 ;
12645 double val3 ;
12646 int ecode3 = 0 ;
12647 PyObject * obj0 = 0 ;
12648 PyObject * obj1 = 0 ;
12649 PyObject * obj2 = 0 ;
12650 char * kwnames[] = {
12651 (char *) "h",(char *) "s",(char *) "v", NULL
12652 };
12653
12654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12655 if (obj0) {
12656 ecode1 = SWIG_AsVal_double(obj0, &val1);
12657 if (!SWIG_IsOK(ecode1)) {
12658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12659 }
12660 arg1 = static_cast< double >(val1);
12661 }
12662 if (obj1) {
12663 ecode2 = SWIG_AsVal_double(obj1, &val2);
12664 if (!SWIG_IsOK(ecode2)) {
12665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12666 }
12667 arg2 = static_cast< double >(val2);
12668 }
12669 if (obj2) {
12670 ecode3 = SWIG_AsVal_double(obj2, &val3);
12671 if (!SWIG_IsOK(ecode3)) {
12672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12673 }
12674 arg3 = static_cast< double >(val3);
12675 }
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12679 wxPyEndAllowThreads(__tstate);
12680 if (PyErr_Occurred()) SWIG_fail;
12681 }
12682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12683 return resultobj;
12684 fail:
12685 return NULL;
12686 }
12687
12688
12689 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12690 PyObject *resultobj = 0;
12691 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12692 double arg2 ;
12693 void *argp1 = 0 ;
12694 int res1 = 0 ;
12695 double val2 ;
12696 int ecode2 = 0 ;
12697 PyObject *swig_obj[2] ;
12698
12699 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12701 if (!SWIG_IsOK(res1)) {
12702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12703 }
12704 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12705 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12706 if (!SWIG_IsOK(ecode2)) {
12707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12708 }
12709 arg2 = static_cast< double >(val2);
12710 if (arg1) (arg1)->hue = arg2;
12711
12712 resultobj = SWIG_Py_Void();
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12720 PyObject *resultobj = 0;
12721 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12722 double result;
12723 void *argp1 = 0 ;
12724 int res1 = 0 ;
12725 PyObject *swig_obj[1] ;
12726
12727 if (!args) SWIG_fail;
12728 swig_obj[0] = args;
12729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12730 if (!SWIG_IsOK(res1)) {
12731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12732 }
12733 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12734 result = (double) ((arg1)->hue);
12735 resultobj = SWIG_From_double(static_cast< double >(result));
12736 return resultobj;
12737 fail:
12738 return NULL;
12739 }
12740
12741
12742 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12743 PyObject *resultobj = 0;
12744 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12745 double arg2 ;
12746 void *argp1 = 0 ;
12747 int res1 = 0 ;
12748 double val2 ;
12749 int ecode2 = 0 ;
12750 PyObject *swig_obj[2] ;
12751
12752 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12754 if (!SWIG_IsOK(res1)) {
12755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12756 }
12757 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12758 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12759 if (!SWIG_IsOK(ecode2)) {
12760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12761 }
12762 arg2 = static_cast< double >(val2);
12763 if (arg1) (arg1)->saturation = arg2;
12764
12765 resultobj = SWIG_Py_Void();
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12773 PyObject *resultobj = 0;
12774 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12775 double result;
12776 void *argp1 = 0 ;
12777 int res1 = 0 ;
12778 PyObject *swig_obj[1] ;
12779
12780 if (!args) SWIG_fail;
12781 swig_obj[0] = args;
12782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12783 if (!SWIG_IsOK(res1)) {
12784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12785 }
12786 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12787 result = (double) ((arg1)->saturation);
12788 resultobj = SWIG_From_double(static_cast< double >(result));
12789 return resultobj;
12790 fail:
12791 return NULL;
12792 }
12793
12794
12795 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12796 PyObject *resultobj = 0;
12797 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12798 double arg2 ;
12799 void *argp1 = 0 ;
12800 int res1 = 0 ;
12801 double val2 ;
12802 int ecode2 = 0 ;
12803 PyObject *swig_obj[2] ;
12804
12805 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12807 if (!SWIG_IsOK(res1)) {
12808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12809 }
12810 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12811 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12812 if (!SWIG_IsOK(ecode2)) {
12813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12814 }
12815 arg2 = static_cast< double >(val2);
12816 if (arg1) (arg1)->value = arg2;
12817
12818 resultobj = SWIG_Py_Void();
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12826 PyObject *resultobj = 0;
12827 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12828 double result;
12829 void *argp1 = 0 ;
12830 int res1 = 0 ;
12831 PyObject *swig_obj[1] ;
12832
12833 if (!args) SWIG_fail;
12834 swig_obj[0] = args;
12835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12836 if (!SWIG_IsOK(res1)) {
12837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12838 }
12839 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12840 result = (double) ((arg1)->value);
12841 resultobj = SWIG_From_double(static_cast< double >(result));
12842 return resultobj;
12843 fail:
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12849 PyObject *obj;
12850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12851 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12852 return SWIG_Py_Void();
12853 }
12854
12855 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12856 return SWIG_Python_InitShadowInstance(args);
12857 }
12858
12859 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12860 PyObject *resultobj = 0;
12861 wxString *arg1 = 0 ;
12862 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12863 int arg3 = (int) -1 ;
12864 wxImage *result = 0 ;
12865 bool temp1 = false ;
12866 long val2 ;
12867 int ecode2 = 0 ;
12868 int val3 ;
12869 int ecode3 = 0 ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 PyObject * obj2 = 0 ;
12873 char * kwnames[] = {
12874 (char *) "name",(char *) "type",(char *) "index", NULL
12875 };
12876
12877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12878 {
12879 arg1 = wxString_in_helper(obj0);
12880 if (arg1 == NULL) SWIG_fail;
12881 temp1 = true;
12882 }
12883 if (obj1) {
12884 ecode2 = SWIG_AsVal_long(obj1, &val2);
12885 if (!SWIG_IsOK(ecode2)) {
12886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12887 }
12888 arg2 = static_cast< long >(val2);
12889 }
12890 if (obj2) {
12891 ecode3 = SWIG_AsVal_int(obj2, &val3);
12892 if (!SWIG_IsOK(ecode3)) {
12893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12894 }
12895 arg3 = static_cast< int >(val3);
12896 }
12897 {
12898 PyThreadState* __tstate = wxPyBeginAllowThreads();
12899 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12900 wxPyEndAllowThreads(__tstate);
12901 if (PyErr_Occurred()) SWIG_fail;
12902 }
12903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12904 {
12905 if (temp1)
12906 delete arg1;
12907 }
12908 return resultobj;
12909 fail:
12910 {
12911 if (temp1)
12912 delete arg1;
12913 }
12914 return NULL;
12915 }
12916
12917
12918 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12919 PyObject *resultobj = 0;
12920 wxImage *arg1 = (wxImage *) 0 ;
12921 void *argp1 = 0 ;
12922 int res1 = 0 ;
12923 PyObject *swig_obj[1] ;
12924
12925 if (!args) SWIG_fail;
12926 swig_obj[0] = args;
12927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12928 if (!SWIG_IsOK(res1)) {
12929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12930 }
12931 arg1 = reinterpret_cast< wxImage * >(argp1);
12932 {
12933 PyThreadState* __tstate = wxPyBeginAllowThreads();
12934 delete arg1;
12935
12936 wxPyEndAllowThreads(__tstate);
12937 if (PyErr_Occurred()) SWIG_fail;
12938 }
12939 resultobj = SWIG_Py_Void();
12940 return resultobj;
12941 fail:
12942 return NULL;
12943 }
12944
12945
12946 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12947 PyObject *resultobj = 0;
12948 wxString *arg1 = 0 ;
12949 wxString *arg2 = 0 ;
12950 int arg3 = (int) -1 ;
12951 wxImage *result = 0 ;
12952 bool temp1 = false ;
12953 bool temp2 = false ;
12954 int val3 ;
12955 int ecode3 = 0 ;
12956 PyObject * obj0 = 0 ;
12957 PyObject * obj1 = 0 ;
12958 PyObject * obj2 = 0 ;
12959 char * kwnames[] = {
12960 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12961 };
12962
12963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12964 {
12965 arg1 = wxString_in_helper(obj0);
12966 if (arg1 == NULL) SWIG_fail;
12967 temp1 = true;
12968 }
12969 {
12970 arg2 = wxString_in_helper(obj1);
12971 if (arg2 == NULL) SWIG_fail;
12972 temp2 = true;
12973 }
12974 if (obj2) {
12975 ecode3 = SWIG_AsVal_int(obj2, &val3);
12976 if (!SWIG_IsOK(ecode3)) {
12977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12978 }
12979 arg3 = static_cast< int >(val3);
12980 }
12981 {
12982 PyThreadState* __tstate = wxPyBeginAllowThreads();
12983 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12984 wxPyEndAllowThreads(__tstate);
12985 if (PyErr_Occurred()) SWIG_fail;
12986 }
12987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12988 {
12989 if (temp1)
12990 delete arg1;
12991 }
12992 {
12993 if (temp2)
12994 delete arg2;
12995 }
12996 return resultobj;
12997 fail:
12998 {
12999 if (temp1)
13000 delete arg1;
13001 }
13002 {
13003 if (temp2)
13004 delete arg2;
13005 }
13006 return NULL;
13007 }
13008
13009
13010 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13011 PyObject *resultobj = 0;
13012 wxInputStream *arg1 = 0 ;
13013 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13014 int arg3 = (int) -1 ;
13015 wxImage *result = 0 ;
13016 wxPyInputStream *temp1 ;
13017 bool created1 ;
13018 long val2 ;
13019 int ecode2 = 0 ;
13020 int val3 ;
13021 int ecode3 = 0 ;
13022 PyObject * obj0 = 0 ;
13023 PyObject * obj1 = 0 ;
13024 PyObject * obj2 = 0 ;
13025 char * kwnames[] = {
13026 (char *) "stream",(char *) "type",(char *) "index", NULL
13027 };
13028
13029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13030 {
13031 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13032 arg1 = temp1->m_wxis;
13033 created1 = false;
13034 } else {
13035 PyErr_Clear(); // clear the failure of the wxPyConvert above
13036 arg1 = wxPyCBInputStream_create(obj0, false);
13037 if (arg1 == NULL) {
13038 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13039 SWIG_fail;
13040 }
13041 created1 = true;
13042 }
13043 }
13044 if (obj1) {
13045 ecode2 = SWIG_AsVal_long(obj1, &val2);
13046 if (!SWIG_IsOK(ecode2)) {
13047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13048 }
13049 arg2 = static_cast< long >(val2);
13050 }
13051 if (obj2) {
13052 ecode3 = SWIG_AsVal_int(obj2, &val3);
13053 if (!SWIG_IsOK(ecode3)) {
13054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13055 }
13056 arg3 = static_cast< int >(val3);
13057 }
13058 {
13059 PyThreadState* __tstate = wxPyBeginAllowThreads();
13060 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13061 wxPyEndAllowThreads(__tstate);
13062 if (PyErr_Occurred()) SWIG_fail;
13063 }
13064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13065 {
13066 if (created1) delete arg1;
13067 }
13068 return resultobj;
13069 fail:
13070 {
13071 if (created1) delete arg1;
13072 }
13073 return NULL;
13074 }
13075
13076
13077 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13078 PyObject *resultobj = 0;
13079 wxInputStream *arg1 = 0 ;
13080 wxString *arg2 = 0 ;
13081 int arg3 = (int) -1 ;
13082 wxImage *result = 0 ;
13083 wxPyInputStream *temp1 ;
13084 bool created1 ;
13085 bool temp2 = false ;
13086 int val3 ;
13087 int ecode3 = 0 ;
13088 PyObject * obj0 = 0 ;
13089 PyObject * obj1 = 0 ;
13090 PyObject * obj2 = 0 ;
13091 char * kwnames[] = {
13092 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13093 };
13094
13095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13096 {
13097 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13098 arg1 = temp1->m_wxis;
13099 created1 = false;
13100 } else {
13101 PyErr_Clear(); // clear the failure of the wxPyConvert above
13102 arg1 = wxPyCBInputStream_create(obj0, false);
13103 if (arg1 == NULL) {
13104 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13105 SWIG_fail;
13106 }
13107 created1 = true;
13108 }
13109 }
13110 {
13111 arg2 = wxString_in_helper(obj1);
13112 if (arg2 == NULL) SWIG_fail;
13113 temp2 = true;
13114 }
13115 if (obj2) {
13116 ecode3 = SWIG_AsVal_int(obj2, &val3);
13117 if (!SWIG_IsOK(ecode3)) {
13118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13119 }
13120 arg3 = static_cast< int >(val3);
13121 }
13122 {
13123 PyThreadState* __tstate = wxPyBeginAllowThreads();
13124 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13129 {
13130 if (created1) delete arg1;
13131 }
13132 {
13133 if (temp2)
13134 delete arg2;
13135 }
13136 return resultobj;
13137 fail:
13138 {
13139 if (created1) delete arg1;
13140 }
13141 {
13142 if (temp2)
13143 delete arg2;
13144 }
13145 return NULL;
13146 }
13147
13148
13149 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13150 PyObject *resultobj = 0;
13151 int arg1 = (int) 0 ;
13152 int arg2 = (int) 0 ;
13153 bool arg3 = (bool) true ;
13154 wxImage *result = 0 ;
13155 int val1 ;
13156 int ecode1 = 0 ;
13157 int val2 ;
13158 int ecode2 = 0 ;
13159 bool val3 ;
13160 int ecode3 = 0 ;
13161 PyObject * obj0 = 0 ;
13162 PyObject * obj1 = 0 ;
13163 PyObject * obj2 = 0 ;
13164 char * kwnames[] = {
13165 (char *) "width",(char *) "height",(char *) "clear", NULL
13166 };
13167
13168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13169 if (obj0) {
13170 ecode1 = SWIG_AsVal_int(obj0, &val1);
13171 if (!SWIG_IsOK(ecode1)) {
13172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13173 }
13174 arg1 = static_cast< int >(val1);
13175 }
13176 if (obj1) {
13177 ecode2 = SWIG_AsVal_int(obj1, &val2);
13178 if (!SWIG_IsOK(ecode2)) {
13179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13180 }
13181 arg2 = static_cast< int >(val2);
13182 }
13183 if (obj2) {
13184 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13185 if (!SWIG_IsOK(ecode3)) {
13186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13187 }
13188 arg3 = static_cast< bool >(val3);
13189 }
13190 {
13191 PyThreadState* __tstate = wxPyBeginAllowThreads();
13192 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj = 0;
13205 wxBitmap *arg1 = 0 ;
13206 wxImage *result = 0 ;
13207 void *argp1 = 0 ;
13208 int res1 = 0 ;
13209 PyObject * obj0 = 0 ;
13210 char * kwnames[] = {
13211 (char *) "bitmap", NULL
13212 };
13213
13214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13215 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13216 if (!SWIG_IsOK(res1)) {
13217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13218 }
13219 if (!argp1) {
13220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13221 }
13222 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13223 {
13224 if (!wxPyCheckForApp()) SWIG_fail;
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13231 return resultobj;
13232 fail:
13233 return NULL;
13234 }
13235
13236
13237 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13238 PyObject *resultobj = 0;
13239 int arg1 ;
13240 int arg2 ;
13241 buffer arg3 ;
13242 int arg4 ;
13243 wxImage *result = 0 ;
13244 int val1 ;
13245 int ecode1 = 0 ;
13246 int val2 ;
13247 int ecode2 = 0 ;
13248 PyObject * obj0 = 0 ;
13249 PyObject * obj1 = 0 ;
13250 PyObject * obj2 = 0 ;
13251 char * kwnames[] = {
13252 (char *) "width",(char *) "height",(char *) "data", NULL
13253 };
13254
13255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13256 ecode1 = SWIG_AsVal_int(obj0, &val1);
13257 if (!SWIG_IsOK(ecode1)) {
13258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13259 }
13260 arg1 = static_cast< int >(val1);
13261 ecode2 = SWIG_AsVal_int(obj1, &val2);
13262 if (!SWIG_IsOK(ecode2)) {
13263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13264 }
13265 arg2 = static_cast< int >(val2);
13266 {
13267 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13268 }
13269 {
13270 PyThreadState* __tstate = wxPyBeginAllowThreads();
13271 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13272 wxPyEndAllowThreads(__tstate);
13273 if (PyErr_Occurred()) SWIG_fail;
13274 }
13275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj = 0;
13284 int arg1 ;
13285 int arg2 ;
13286 buffer arg3 ;
13287 int arg4 ;
13288 buffer arg5 ;
13289 int arg6 ;
13290 wxImage *result = 0 ;
13291 int val1 ;
13292 int ecode1 = 0 ;
13293 int val2 ;
13294 int ecode2 = 0 ;
13295 PyObject * obj0 = 0 ;
13296 PyObject * obj1 = 0 ;
13297 PyObject * obj2 = 0 ;
13298 PyObject * obj3 = 0 ;
13299 char * kwnames[] = {
13300 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13301 };
13302
13303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13304 ecode1 = SWIG_AsVal_int(obj0, &val1);
13305 if (!SWIG_IsOK(ecode1)) {
13306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13307 }
13308 arg1 = static_cast< int >(val1);
13309 ecode2 = SWIG_AsVal_int(obj1, &val2);
13310 if (!SWIG_IsOK(ecode2)) {
13311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13312 }
13313 arg2 = static_cast< int >(val2);
13314 {
13315 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13316 }
13317 {
13318 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13319 }
13320 {
13321 PyThreadState* __tstate = wxPyBeginAllowThreads();
13322 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13323 wxPyEndAllowThreads(__tstate);
13324 if (PyErr_Occurred()) SWIG_fail;
13325 }
13326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13327 return resultobj;
13328 fail:
13329 return NULL;
13330 }
13331
13332
13333 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13334 PyObject *resultobj = 0;
13335 wxImage *arg1 = (wxImage *) 0 ;
13336 int arg2 ;
13337 int arg3 ;
13338 bool arg4 = (bool) true ;
13339 void *argp1 = 0 ;
13340 int res1 = 0 ;
13341 int val2 ;
13342 int ecode2 = 0 ;
13343 int val3 ;
13344 int ecode3 = 0 ;
13345 bool val4 ;
13346 int ecode4 = 0 ;
13347 PyObject * obj0 = 0 ;
13348 PyObject * obj1 = 0 ;
13349 PyObject * obj2 = 0 ;
13350 PyObject * obj3 = 0 ;
13351 char * kwnames[] = {
13352 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13353 };
13354
13355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13357 if (!SWIG_IsOK(res1)) {
13358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13359 }
13360 arg1 = reinterpret_cast< wxImage * >(argp1);
13361 ecode2 = SWIG_AsVal_int(obj1, &val2);
13362 if (!SWIG_IsOK(ecode2)) {
13363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13364 }
13365 arg2 = static_cast< int >(val2);
13366 ecode3 = SWIG_AsVal_int(obj2, &val3);
13367 if (!SWIG_IsOK(ecode3)) {
13368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13369 }
13370 arg3 = static_cast< int >(val3);
13371 if (obj3) {
13372 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13373 if (!SWIG_IsOK(ecode4)) {
13374 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13375 }
13376 arg4 = static_cast< bool >(val4);
13377 }
13378 {
13379 PyThreadState* __tstate = wxPyBeginAllowThreads();
13380 (arg1)->Create(arg2,arg3,arg4);
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 resultobj = SWIG_Py_Void();
13385 return resultobj;
13386 fail:
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13392 PyObject *resultobj = 0;
13393 wxImage *arg1 = (wxImage *) 0 ;
13394 void *argp1 = 0 ;
13395 int res1 = 0 ;
13396 PyObject *swig_obj[1] ;
13397
13398 if (!args) SWIG_fail;
13399 swig_obj[0] = args;
13400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13403 }
13404 arg1 = reinterpret_cast< wxImage * >(argp1);
13405 {
13406 PyThreadState* __tstate = wxPyBeginAllowThreads();
13407 (arg1)->Destroy();
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 resultobj = SWIG_Py_Void();
13412 return resultobj;
13413 fail:
13414 return NULL;
13415 }
13416
13417
13418 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13419 PyObject *resultobj = 0;
13420 wxImage *arg1 = (wxImage *) 0 ;
13421 int arg2 ;
13422 int arg3 ;
13423 SwigValueWrapper<wxImage > result;
13424 void *argp1 = 0 ;
13425 int res1 = 0 ;
13426 int val2 ;
13427 int ecode2 = 0 ;
13428 int val3 ;
13429 int ecode3 = 0 ;
13430 PyObject * obj0 = 0 ;
13431 PyObject * obj1 = 0 ;
13432 PyObject * obj2 = 0 ;
13433 char * kwnames[] = {
13434 (char *) "self",(char *) "width",(char *) "height", NULL
13435 };
13436
13437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13439 if (!SWIG_IsOK(res1)) {
13440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13441 }
13442 arg1 = reinterpret_cast< wxImage * >(argp1);
13443 ecode2 = SWIG_AsVal_int(obj1, &val2);
13444 if (!SWIG_IsOK(ecode2)) {
13445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13446 }
13447 arg2 = static_cast< int >(val2);
13448 ecode3 = SWIG_AsVal_int(obj2, &val3);
13449 if (!SWIG_IsOK(ecode3)) {
13450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13451 }
13452 arg3 = static_cast< int >(val3);
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = (arg1)->Scale(arg2,arg3);
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13460 return resultobj;
13461 fail:
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj = 0;
13468 wxImage *arg1 = (wxImage *) 0 ;
13469 int arg2 ;
13470 int arg3 ;
13471 SwigValueWrapper<wxImage > result;
13472 void *argp1 = 0 ;
13473 int res1 = 0 ;
13474 int val2 ;
13475 int ecode2 = 0 ;
13476 int val3 ;
13477 int ecode3 = 0 ;
13478 PyObject * obj0 = 0 ;
13479 PyObject * obj1 = 0 ;
13480 PyObject * obj2 = 0 ;
13481 char * kwnames[] = {
13482 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13483 };
13484
13485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13487 if (!SWIG_IsOK(res1)) {
13488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13489 }
13490 arg1 = reinterpret_cast< wxImage * >(argp1);
13491 ecode2 = SWIG_AsVal_int(obj1, &val2);
13492 if (!SWIG_IsOK(ecode2)) {
13493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13494 }
13495 arg2 = static_cast< int >(val2);
13496 ecode3 = SWIG_AsVal_int(obj2, &val3);
13497 if (!SWIG_IsOK(ecode3)) {
13498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13499 }
13500 arg3 = static_cast< int >(val3);
13501 {
13502 PyThreadState* __tstate = wxPyBeginAllowThreads();
13503 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13504 wxPyEndAllowThreads(__tstate);
13505 if (PyErr_Occurred()) SWIG_fail;
13506 }
13507 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13508 return resultobj;
13509 fail:
13510 return NULL;
13511 }
13512
13513
13514 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj = 0;
13516 wxImage *arg1 = (wxImage *) 0 ;
13517 int arg2 ;
13518 int arg3 ;
13519 wxImage *result = 0 ;
13520 void *argp1 = 0 ;
13521 int res1 = 0 ;
13522 int val2 ;
13523 int ecode2 = 0 ;
13524 int val3 ;
13525 int ecode3 = 0 ;
13526 PyObject * obj0 = 0 ;
13527 PyObject * obj1 = 0 ;
13528 PyObject * obj2 = 0 ;
13529 char * kwnames[] = {
13530 (char *) "self",(char *) "width",(char *) "height", NULL
13531 };
13532
13533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13535 if (!SWIG_IsOK(res1)) {
13536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13537 }
13538 arg1 = reinterpret_cast< wxImage * >(argp1);
13539 ecode2 = SWIG_AsVal_int(obj1, &val2);
13540 if (!SWIG_IsOK(ecode2)) {
13541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13542 }
13543 arg2 = static_cast< int >(val2);
13544 ecode3 = SWIG_AsVal_int(obj2, &val3);
13545 if (!SWIG_IsOK(ecode3)) {
13546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13547 }
13548 arg3 = static_cast< int >(val3);
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 {
13552 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13553 result = (wxImage *) &_result_ref;
13554 }
13555 wxPyEndAllowThreads(__tstate);
13556 if (PyErr_Occurred()) SWIG_fail;
13557 }
13558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13559 return resultobj;
13560 fail:
13561 return NULL;
13562 }
13563
13564
13565 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13566 PyObject *resultobj = 0;
13567 wxImage *arg1 = (wxImage *) 0 ;
13568 wxSize *arg2 = 0 ;
13569 wxPoint *arg3 = 0 ;
13570 int arg4 = (int) -1 ;
13571 int arg5 = (int) -1 ;
13572 int arg6 = (int) -1 ;
13573 wxImage *result = 0 ;
13574 void *argp1 = 0 ;
13575 int res1 = 0 ;
13576 wxSize temp2 ;
13577 wxPoint temp3 ;
13578 int val4 ;
13579 int ecode4 = 0 ;
13580 int val5 ;
13581 int ecode5 = 0 ;
13582 int val6 ;
13583 int ecode6 = 0 ;
13584 PyObject * obj0 = 0 ;
13585 PyObject * obj1 = 0 ;
13586 PyObject * obj2 = 0 ;
13587 PyObject * obj3 = 0 ;
13588 PyObject * obj4 = 0 ;
13589 PyObject * obj5 = 0 ;
13590 char * kwnames[] = {
13591 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13592 };
13593
13594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13596 if (!SWIG_IsOK(res1)) {
13597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13598 }
13599 arg1 = reinterpret_cast< wxImage * >(argp1);
13600 {
13601 arg2 = &temp2;
13602 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13603 }
13604 {
13605 arg3 = &temp3;
13606 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13607 }
13608 if (obj3) {
13609 ecode4 = SWIG_AsVal_int(obj3, &val4);
13610 if (!SWIG_IsOK(ecode4)) {
13611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13612 }
13613 arg4 = static_cast< int >(val4);
13614 }
13615 if (obj4) {
13616 ecode5 = SWIG_AsVal_int(obj4, &val5);
13617 if (!SWIG_IsOK(ecode5)) {
13618 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13619 }
13620 arg5 = static_cast< int >(val5);
13621 }
13622 if (obj5) {
13623 ecode6 = SWIG_AsVal_int(obj5, &val6);
13624 if (!SWIG_IsOK(ecode6)) {
13625 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13626 }
13627 arg6 = static_cast< int >(val6);
13628 }
13629 {
13630 PyThreadState* __tstate = wxPyBeginAllowThreads();
13631 {
13632 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13633 result = (wxImage *) &_result_ref;
13634 }
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13639 return resultobj;
13640 fail:
13641 return NULL;
13642 }
13643
13644
13645 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13646 PyObject *resultobj = 0;
13647 wxImage *arg1 = (wxImage *) 0 ;
13648 int arg2 ;
13649 int arg3 ;
13650 byte arg4 ;
13651 byte arg5 ;
13652 byte arg6 ;
13653 void *argp1 = 0 ;
13654 int res1 = 0 ;
13655 int val2 ;
13656 int ecode2 = 0 ;
13657 int val3 ;
13658 int ecode3 = 0 ;
13659 unsigned char val4 ;
13660 int ecode4 = 0 ;
13661 unsigned char val5 ;
13662 int ecode5 = 0 ;
13663 unsigned char val6 ;
13664 int ecode6 = 0 ;
13665 PyObject * obj0 = 0 ;
13666 PyObject * obj1 = 0 ;
13667 PyObject * obj2 = 0 ;
13668 PyObject * obj3 = 0 ;
13669 PyObject * obj4 = 0 ;
13670 PyObject * obj5 = 0 ;
13671 char * kwnames[] = {
13672 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13673 };
13674
13675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13677 if (!SWIG_IsOK(res1)) {
13678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13679 }
13680 arg1 = reinterpret_cast< wxImage * >(argp1);
13681 ecode2 = SWIG_AsVal_int(obj1, &val2);
13682 if (!SWIG_IsOK(ecode2)) {
13683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13684 }
13685 arg2 = static_cast< int >(val2);
13686 ecode3 = SWIG_AsVal_int(obj2, &val3);
13687 if (!SWIG_IsOK(ecode3)) {
13688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13689 }
13690 arg3 = static_cast< int >(val3);
13691 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13692 if (!SWIG_IsOK(ecode4)) {
13693 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13694 }
13695 arg4 = static_cast< byte >(val4);
13696 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13697 if (!SWIG_IsOK(ecode5)) {
13698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13699 }
13700 arg5 = static_cast< byte >(val5);
13701 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13702 if (!SWIG_IsOK(ecode6)) {
13703 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13704 }
13705 arg6 = static_cast< byte >(val6);
13706 {
13707 PyThreadState* __tstate = wxPyBeginAllowThreads();
13708 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13709 wxPyEndAllowThreads(__tstate);
13710 if (PyErr_Occurred()) SWIG_fail;
13711 }
13712 resultobj = SWIG_Py_Void();
13713 return resultobj;
13714 fail:
13715 return NULL;
13716 }
13717
13718
13719 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13720 PyObject *resultobj = 0;
13721 wxImage *arg1 = (wxImage *) 0 ;
13722 wxRect *arg2 = 0 ;
13723 byte arg3 ;
13724 byte arg4 ;
13725 byte arg5 ;
13726 void *argp1 = 0 ;
13727 int res1 = 0 ;
13728 wxRect temp2 ;
13729 unsigned char val3 ;
13730 int ecode3 = 0 ;
13731 unsigned char val4 ;
13732 int ecode4 = 0 ;
13733 unsigned char val5 ;
13734 int ecode5 = 0 ;
13735 PyObject * obj0 = 0 ;
13736 PyObject * obj1 = 0 ;
13737 PyObject * obj2 = 0 ;
13738 PyObject * obj3 = 0 ;
13739 PyObject * obj4 = 0 ;
13740 char * kwnames[] = {
13741 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13742 };
13743
13744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13746 if (!SWIG_IsOK(res1)) {
13747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13748 }
13749 arg1 = reinterpret_cast< wxImage * >(argp1);
13750 {
13751 arg2 = &temp2;
13752 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13753 }
13754 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13755 if (!SWIG_IsOK(ecode3)) {
13756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13757 }
13758 arg3 = static_cast< byte >(val3);
13759 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13760 if (!SWIG_IsOK(ecode4)) {
13761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13762 }
13763 arg4 = static_cast< byte >(val4);
13764 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13765 if (!SWIG_IsOK(ecode5)) {
13766 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13767 }
13768 arg5 = static_cast< byte >(val5);
13769 {
13770 PyThreadState* __tstate = wxPyBeginAllowThreads();
13771 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13772 wxPyEndAllowThreads(__tstate);
13773 if (PyErr_Occurred()) SWIG_fail;
13774 }
13775 resultobj = SWIG_Py_Void();
13776 return resultobj;
13777 fail:
13778 return NULL;
13779 }
13780
13781
13782 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13783 PyObject *resultobj = 0;
13784 wxImage *arg1 = (wxImage *) 0 ;
13785 int arg2 ;
13786 int arg3 ;
13787 byte result;
13788 void *argp1 = 0 ;
13789 int res1 = 0 ;
13790 int val2 ;
13791 int ecode2 = 0 ;
13792 int val3 ;
13793 int ecode3 = 0 ;
13794 PyObject * obj0 = 0 ;
13795 PyObject * obj1 = 0 ;
13796 PyObject * obj2 = 0 ;
13797 char * kwnames[] = {
13798 (char *) "self",(char *) "x",(char *) "y", NULL
13799 };
13800
13801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13803 if (!SWIG_IsOK(res1)) {
13804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13805 }
13806 arg1 = reinterpret_cast< wxImage * >(argp1);
13807 ecode2 = SWIG_AsVal_int(obj1, &val2);
13808 if (!SWIG_IsOK(ecode2)) {
13809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13810 }
13811 arg2 = static_cast< int >(val2);
13812 ecode3 = SWIG_AsVal_int(obj2, &val3);
13813 if (!SWIG_IsOK(ecode3)) {
13814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13815 }
13816 arg3 = static_cast< int >(val3);
13817 {
13818 PyThreadState* __tstate = wxPyBeginAllowThreads();
13819 result = (byte)(arg1)->GetRed(arg2,arg3);
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13824 return resultobj;
13825 fail:
13826 return NULL;
13827 }
13828
13829
13830 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13831 PyObject *resultobj = 0;
13832 wxImage *arg1 = (wxImage *) 0 ;
13833 int arg2 ;
13834 int arg3 ;
13835 byte result;
13836 void *argp1 = 0 ;
13837 int res1 = 0 ;
13838 int val2 ;
13839 int ecode2 = 0 ;
13840 int val3 ;
13841 int ecode3 = 0 ;
13842 PyObject * obj0 = 0 ;
13843 PyObject * obj1 = 0 ;
13844 PyObject * obj2 = 0 ;
13845 char * kwnames[] = {
13846 (char *) "self",(char *) "x",(char *) "y", NULL
13847 };
13848
13849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13851 if (!SWIG_IsOK(res1)) {
13852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13853 }
13854 arg1 = reinterpret_cast< wxImage * >(argp1);
13855 ecode2 = SWIG_AsVal_int(obj1, &val2);
13856 if (!SWIG_IsOK(ecode2)) {
13857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13858 }
13859 arg2 = static_cast< int >(val2);
13860 ecode3 = SWIG_AsVal_int(obj2, &val3);
13861 if (!SWIG_IsOK(ecode3)) {
13862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13863 }
13864 arg3 = static_cast< int >(val3);
13865 {
13866 PyThreadState* __tstate = wxPyBeginAllowThreads();
13867 result = (byte)(arg1)->GetGreen(arg2,arg3);
13868 wxPyEndAllowThreads(__tstate);
13869 if (PyErr_Occurred()) SWIG_fail;
13870 }
13871 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13872 return resultobj;
13873 fail:
13874 return NULL;
13875 }
13876
13877
13878 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13879 PyObject *resultobj = 0;
13880 wxImage *arg1 = (wxImage *) 0 ;
13881 int arg2 ;
13882 int arg3 ;
13883 byte result;
13884 void *argp1 = 0 ;
13885 int res1 = 0 ;
13886 int val2 ;
13887 int ecode2 = 0 ;
13888 int val3 ;
13889 int ecode3 = 0 ;
13890 PyObject * obj0 = 0 ;
13891 PyObject * obj1 = 0 ;
13892 PyObject * obj2 = 0 ;
13893 char * kwnames[] = {
13894 (char *) "self",(char *) "x",(char *) "y", NULL
13895 };
13896
13897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13899 if (!SWIG_IsOK(res1)) {
13900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13901 }
13902 arg1 = reinterpret_cast< wxImage * >(argp1);
13903 ecode2 = SWIG_AsVal_int(obj1, &val2);
13904 if (!SWIG_IsOK(ecode2)) {
13905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13906 }
13907 arg2 = static_cast< int >(val2);
13908 ecode3 = SWIG_AsVal_int(obj2, &val3);
13909 if (!SWIG_IsOK(ecode3)) {
13910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13911 }
13912 arg3 = static_cast< int >(val3);
13913 {
13914 PyThreadState* __tstate = wxPyBeginAllowThreads();
13915 result = (byte)(arg1)->GetBlue(arg2,arg3);
13916 wxPyEndAllowThreads(__tstate);
13917 if (PyErr_Occurred()) SWIG_fail;
13918 }
13919 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13920 return resultobj;
13921 fail:
13922 return NULL;
13923 }
13924
13925
13926 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13927 PyObject *resultobj = 0;
13928 wxImage *arg1 = (wxImage *) 0 ;
13929 int arg2 ;
13930 int arg3 ;
13931 byte arg4 ;
13932 void *argp1 = 0 ;
13933 int res1 = 0 ;
13934 int val2 ;
13935 int ecode2 = 0 ;
13936 int val3 ;
13937 int ecode3 = 0 ;
13938 unsigned char val4 ;
13939 int ecode4 = 0 ;
13940 PyObject * obj0 = 0 ;
13941 PyObject * obj1 = 0 ;
13942 PyObject * obj2 = 0 ;
13943 PyObject * obj3 = 0 ;
13944 char * kwnames[] = {
13945 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13946 };
13947
13948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13950 if (!SWIG_IsOK(res1)) {
13951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13952 }
13953 arg1 = reinterpret_cast< wxImage * >(argp1);
13954 ecode2 = SWIG_AsVal_int(obj1, &val2);
13955 if (!SWIG_IsOK(ecode2)) {
13956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13957 }
13958 arg2 = static_cast< int >(val2);
13959 ecode3 = SWIG_AsVal_int(obj2, &val3);
13960 if (!SWIG_IsOK(ecode3)) {
13961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13962 }
13963 arg3 = static_cast< int >(val3);
13964 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13965 if (!SWIG_IsOK(ecode4)) {
13966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13967 }
13968 arg4 = static_cast< byte >(val4);
13969 {
13970 PyThreadState* __tstate = wxPyBeginAllowThreads();
13971 (arg1)->SetAlpha(arg2,arg3,arg4);
13972 wxPyEndAllowThreads(__tstate);
13973 if (PyErr_Occurred()) SWIG_fail;
13974 }
13975 resultobj = SWIG_Py_Void();
13976 return resultobj;
13977 fail:
13978 return NULL;
13979 }
13980
13981
13982 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13983 PyObject *resultobj = 0;
13984 wxImage *arg1 = (wxImage *) 0 ;
13985 int arg2 ;
13986 int arg3 ;
13987 byte result;
13988 void *argp1 = 0 ;
13989 int res1 = 0 ;
13990 int val2 ;
13991 int ecode2 = 0 ;
13992 int val3 ;
13993 int ecode3 = 0 ;
13994 PyObject * obj0 = 0 ;
13995 PyObject * obj1 = 0 ;
13996 PyObject * obj2 = 0 ;
13997 char * kwnames[] = {
13998 (char *) "self",(char *) "x",(char *) "y", NULL
13999 };
14000
14001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14003 if (!SWIG_IsOK(res1)) {
14004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14005 }
14006 arg1 = reinterpret_cast< wxImage * >(argp1);
14007 ecode2 = SWIG_AsVal_int(obj1, &val2);
14008 if (!SWIG_IsOK(ecode2)) {
14009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14010 }
14011 arg2 = static_cast< int >(val2);
14012 ecode3 = SWIG_AsVal_int(obj2, &val3);
14013 if (!SWIG_IsOK(ecode3)) {
14014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14015 }
14016 arg3 = static_cast< int >(val3);
14017 {
14018 PyThreadState* __tstate = wxPyBeginAllowThreads();
14019 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14020 wxPyEndAllowThreads(__tstate);
14021 if (PyErr_Occurred()) SWIG_fail;
14022 }
14023 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14024 return resultobj;
14025 fail:
14026 return NULL;
14027 }
14028
14029
14030 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14031 PyObject *resultobj = 0;
14032 wxImage *arg1 = (wxImage *) 0 ;
14033 bool result;
14034 void *argp1 = 0 ;
14035 int res1 = 0 ;
14036 PyObject *swig_obj[1] ;
14037
14038 if (!args) SWIG_fail;
14039 swig_obj[0] = args;
14040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14041 if (!SWIG_IsOK(res1)) {
14042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14043 }
14044 arg1 = reinterpret_cast< wxImage * >(argp1);
14045 {
14046 PyThreadState* __tstate = wxPyBeginAllowThreads();
14047 result = (bool)(arg1)->HasAlpha();
14048 wxPyEndAllowThreads(__tstate);
14049 if (PyErr_Occurred()) SWIG_fail;
14050 }
14051 {
14052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14053 }
14054 return resultobj;
14055 fail:
14056 return NULL;
14057 }
14058
14059
14060 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14061 PyObject *resultobj = 0;
14062 wxImage *arg1 = (wxImage *) 0 ;
14063 void *argp1 = 0 ;
14064 int res1 = 0 ;
14065 PyObject *swig_obj[1] ;
14066
14067 if (!args) SWIG_fail;
14068 swig_obj[0] = args;
14069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14070 if (!SWIG_IsOK(res1)) {
14071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14072 }
14073 arg1 = reinterpret_cast< wxImage * >(argp1);
14074 {
14075 PyThreadState* __tstate = wxPyBeginAllowThreads();
14076 (arg1)->InitAlpha();
14077 wxPyEndAllowThreads(__tstate);
14078 if (PyErr_Occurred()) SWIG_fail;
14079 }
14080 resultobj = SWIG_Py_Void();
14081 return resultobj;
14082 fail:
14083 return NULL;
14084 }
14085
14086
14087 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14088 PyObject *resultobj = 0;
14089 wxImage *arg1 = (wxImage *) 0 ;
14090 int arg2 ;
14091 int arg3 ;
14092 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14093 bool result;
14094 void *argp1 = 0 ;
14095 int res1 = 0 ;
14096 int val2 ;
14097 int ecode2 = 0 ;
14098 int val3 ;
14099 int ecode3 = 0 ;
14100 unsigned char val4 ;
14101 int ecode4 = 0 ;
14102 PyObject * obj0 = 0 ;
14103 PyObject * obj1 = 0 ;
14104 PyObject * obj2 = 0 ;
14105 PyObject * obj3 = 0 ;
14106 char * kwnames[] = {
14107 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14108 };
14109
14110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14112 if (!SWIG_IsOK(res1)) {
14113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14114 }
14115 arg1 = reinterpret_cast< wxImage * >(argp1);
14116 ecode2 = SWIG_AsVal_int(obj1, &val2);
14117 if (!SWIG_IsOK(ecode2)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14119 }
14120 arg2 = static_cast< int >(val2);
14121 ecode3 = SWIG_AsVal_int(obj2, &val3);
14122 if (!SWIG_IsOK(ecode3)) {
14123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14124 }
14125 arg3 = static_cast< int >(val3);
14126 if (obj3) {
14127 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14128 if (!SWIG_IsOK(ecode4)) {
14129 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14130 }
14131 arg4 = static_cast< byte >(val4);
14132 }
14133 {
14134 PyThreadState* __tstate = wxPyBeginAllowThreads();
14135 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14136 wxPyEndAllowThreads(__tstate);
14137 if (PyErr_Occurred()) SWIG_fail;
14138 }
14139 {
14140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14141 }
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14149 PyObject *resultobj = 0;
14150 wxImage *arg1 = (wxImage *) 0 ;
14151 byte *arg2 = (byte *) 0 ;
14152 byte *arg3 = (byte *) 0 ;
14153 byte *arg4 = (byte *) 0 ;
14154 byte arg5 = (byte) 0 ;
14155 byte arg6 = (byte) 0 ;
14156 byte arg7 = (byte) 0 ;
14157 bool result;
14158 void *argp1 = 0 ;
14159 int res1 = 0 ;
14160 byte temp2 ;
14161 int res2 = SWIG_TMPOBJ ;
14162 byte temp3 ;
14163 int res3 = SWIG_TMPOBJ ;
14164 byte temp4 ;
14165 int res4 = SWIG_TMPOBJ ;
14166 unsigned char val5 ;
14167 int ecode5 = 0 ;
14168 unsigned char val6 ;
14169 int ecode6 = 0 ;
14170 unsigned char val7 ;
14171 int ecode7 = 0 ;
14172 PyObject * obj0 = 0 ;
14173 PyObject * obj1 = 0 ;
14174 PyObject * obj2 = 0 ;
14175 PyObject * obj3 = 0 ;
14176 char * kwnames[] = {
14177 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14178 };
14179
14180 arg2 = &temp2;
14181 arg3 = &temp3;
14182 arg4 = &temp4;
14183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14185 if (!SWIG_IsOK(res1)) {
14186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14187 }
14188 arg1 = reinterpret_cast< wxImage * >(argp1);
14189 if (obj1) {
14190 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14191 if (!SWIG_IsOK(ecode5)) {
14192 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14193 }
14194 arg5 = static_cast< byte >(val5);
14195 }
14196 if (obj2) {
14197 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14198 if (!SWIG_IsOK(ecode6)) {
14199 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14200 }
14201 arg6 = static_cast< byte >(val6);
14202 }
14203 if (obj3) {
14204 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14205 if (!SWIG_IsOK(ecode7)) {
14206 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14207 }
14208 arg7 = static_cast< byte >(val7);
14209 }
14210 {
14211 PyThreadState* __tstate = wxPyBeginAllowThreads();
14212 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 {
14217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14218 }
14219 if (SWIG_IsTmpObj(res2)) {
14220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14221 } else {
14222 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14224 }
14225 if (SWIG_IsTmpObj(res3)) {
14226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14227 } else {
14228 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14230 }
14231 if (SWIG_IsTmpObj(res4)) {
14232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14233 } else {
14234 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14236 }
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj = 0;
14245 wxImage *arg1 = (wxImage *) 0 ;
14246 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14247 bool result;
14248 void *argp1 = 0 ;
14249 int res1 = 0 ;
14250 unsigned char val2 ;
14251 int ecode2 = 0 ;
14252 PyObject * obj0 = 0 ;
14253 PyObject * obj1 = 0 ;
14254 char * kwnames[] = {
14255 (char *) "self",(char *) "threshold", NULL
14256 };
14257
14258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14260 if (!SWIG_IsOK(res1)) {
14261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14262 }
14263 arg1 = reinterpret_cast< wxImage * >(argp1);
14264 if (obj1) {
14265 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14266 if (!SWIG_IsOK(ecode2)) {
14267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14268 }
14269 arg2 = static_cast< byte >(val2);
14270 }
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14274 wxPyEndAllowThreads(__tstate);
14275 if (PyErr_Occurred()) SWIG_fail;
14276 }
14277 {
14278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14279 }
14280 return resultobj;
14281 fail:
14282 return NULL;
14283 }
14284
14285
14286 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14287 PyObject *resultobj = 0;
14288 wxImage *arg1 = (wxImage *) 0 ;
14289 byte arg2 ;
14290 byte arg3 ;
14291 byte arg4 ;
14292 bool result;
14293 void *argp1 = 0 ;
14294 int res1 = 0 ;
14295 unsigned char val2 ;
14296 int ecode2 = 0 ;
14297 unsigned char val3 ;
14298 int ecode3 = 0 ;
14299 unsigned char val4 ;
14300 int ecode4 = 0 ;
14301 PyObject * obj0 = 0 ;
14302 PyObject * obj1 = 0 ;
14303 PyObject * obj2 = 0 ;
14304 PyObject * obj3 = 0 ;
14305 char * kwnames[] = {
14306 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14307 };
14308
14309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14311 if (!SWIG_IsOK(res1)) {
14312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14313 }
14314 arg1 = reinterpret_cast< wxImage * >(argp1);
14315 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14316 if (!SWIG_IsOK(ecode2)) {
14317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14318 }
14319 arg2 = static_cast< byte >(val2);
14320 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14321 if (!SWIG_IsOK(ecode3)) {
14322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14323 }
14324 arg3 = static_cast< byte >(val3);
14325 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14326 if (!SWIG_IsOK(ecode4)) {
14327 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14328 }
14329 arg4 = static_cast< byte >(val4);
14330 {
14331 PyThreadState* __tstate = wxPyBeginAllowThreads();
14332 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14333 wxPyEndAllowThreads(__tstate);
14334 if (PyErr_Occurred()) SWIG_fail;
14335 }
14336 {
14337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14338 }
14339 return resultobj;
14340 fail:
14341 return NULL;
14342 }
14343
14344
14345 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14346 PyObject *resultobj = 0;
14347 wxImage *arg1 = (wxImage *) 0 ;
14348 wxImage *arg2 = 0 ;
14349 byte arg3 ;
14350 byte arg4 ;
14351 byte arg5 ;
14352 bool result;
14353 void *argp1 = 0 ;
14354 int res1 = 0 ;
14355 void *argp2 = 0 ;
14356 int res2 = 0 ;
14357 unsigned char val3 ;
14358 int ecode3 = 0 ;
14359 unsigned char val4 ;
14360 int ecode4 = 0 ;
14361 unsigned char val5 ;
14362 int ecode5 = 0 ;
14363 PyObject * obj0 = 0 ;
14364 PyObject * obj1 = 0 ;
14365 PyObject * obj2 = 0 ;
14366 PyObject * obj3 = 0 ;
14367 PyObject * obj4 = 0 ;
14368 char * kwnames[] = {
14369 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14370 };
14371
14372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14374 if (!SWIG_IsOK(res1)) {
14375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14376 }
14377 arg1 = reinterpret_cast< wxImage * >(argp1);
14378 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14379 if (!SWIG_IsOK(res2)) {
14380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14381 }
14382 if (!argp2) {
14383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14384 }
14385 arg2 = reinterpret_cast< wxImage * >(argp2);
14386 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14387 if (!SWIG_IsOK(ecode3)) {
14388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14389 }
14390 arg3 = static_cast< byte >(val3);
14391 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14392 if (!SWIG_IsOK(ecode4)) {
14393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14394 }
14395 arg4 = static_cast< byte >(val4);
14396 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14397 if (!SWIG_IsOK(ecode5)) {
14398 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14399 }
14400 arg5 = static_cast< byte >(val5);
14401 {
14402 PyThreadState* __tstate = wxPyBeginAllowThreads();
14403 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14404 wxPyEndAllowThreads(__tstate);
14405 if (PyErr_Occurred()) SWIG_fail;
14406 }
14407 {
14408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14409 }
14410 return resultobj;
14411 fail:
14412 return NULL;
14413 }
14414
14415
14416 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj = 0;
14418 wxString *arg1 = 0 ;
14419 bool result;
14420 bool temp1 = false ;
14421 PyObject * obj0 = 0 ;
14422 char * kwnames[] = {
14423 (char *) "filename", NULL
14424 };
14425
14426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14427 {
14428 arg1 = wxString_in_helper(obj0);
14429 if (arg1 == NULL) SWIG_fail;
14430 temp1 = true;
14431 }
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14435 wxPyEndAllowThreads(__tstate);
14436 if (PyErr_Occurred()) SWIG_fail;
14437 }
14438 {
14439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14440 }
14441 {
14442 if (temp1)
14443 delete arg1;
14444 }
14445 return resultobj;
14446 fail:
14447 {
14448 if (temp1)
14449 delete arg1;
14450 }
14451 return NULL;
14452 }
14453
14454
14455 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14456 PyObject *resultobj = 0;
14457 wxString *arg1 = 0 ;
14458 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14459 int result;
14460 bool temp1 = false ;
14461 long val2 ;
14462 int ecode2 = 0 ;
14463 PyObject * obj0 = 0 ;
14464 PyObject * obj1 = 0 ;
14465 char * kwnames[] = {
14466 (char *) "filename",(char *) "type", NULL
14467 };
14468
14469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14470 {
14471 arg1 = wxString_in_helper(obj0);
14472 if (arg1 == NULL) SWIG_fail;
14473 temp1 = true;
14474 }
14475 if (obj1) {
14476 ecode2 = SWIG_AsVal_long(obj1, &val2);
14477 if (!SWIG_IsOK(ecode2)) {
14478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14479 }
14480 arg2 = static_cast< long >(val2);
14481 }
14482 {
14483 PyThreadState* __tstate = wxPyBeginAllowThreads();
14484 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14485 wxPyEndAllowThreads(__tstate);
14486 if (PyErr_Occurred()) SWIG_fail;
14487 }
14488 resultobj = SWIG_From_int(static_cast< int >(result));
14489 {
14490 if (temp1)
14491 delete arg1;
14492 }
14493 return resultobj;
14494 fail:
14495 {
14496 if (temp1)
14497 delete arg1;
14498 }
14499 return NULL;
14500 }
14501
14502
14503 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14504 PyObject *resultobj = 0;
14505 wxImage *arg1 = (wxImage *) 0 ;
14506 wxString *arg2 = 0 ;
14507 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14508 int arg4 = (int) -1 ;
14509 bool result;
14510 void *argp1 = 0 ;
14511 int res1 = 0 ;
14512 bool temp2 = false ;
14513 long val3 ;
14514 int ecode3 = 0 ;
14515 int 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 *) "name",(char *) "type",(char *) "index", NULL
14523 };
14524
14525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",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_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14529 }
14530 arg1 = reinterpret_cast< wxImage * >(argp1);
14531 {
14532 arg2 = wxString_in_helper(obj1);
14533 if (arg2 == NULL) SWIG_fail;
14534 temp2 = true;
14535 }
14536 if (obj2) {
14537 ecode3 = SWIG_AsVal_long(obj2, &val3);
14538 if (!SWIG_IsOK(ecode3)) {
14539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14540 }
14541 arg3 = static_cast< long >(val3);
14542 }
14543 if (obj3) {
14544 ecode4 = SWIG_AsVal_int(obj3, &val4);
14545 if (!SWIG_IsOK(ecode4)) {
14546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14547 }
14548 arg4 = static_cast< int >(val4);
14549 }
14550 {
14551 PyThreadState* __tstate = wxPyBeginAllowThreads();
14552 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14553 wxPyEndAllowThreads(__tstate);
14554 if (PyErr_Occurred()) SWIG_fail;
14555 }
14556 {
14557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14558 }
14559 {
14560 if (temp2)
14561 delete arg2;
14562 }
14563 return resultobj;
14564 fail:
14565 {
14566 if (temp2)
14567 delete arg2;
14568 }
14569 return NULL;
14570 }
14571
14572
14573 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14574 PyObject *resultobj = 0;
14575 wxImage *arg1 = (wxImage *) 0 ;
14576 wxString *arg2 = 0 ;
14577 wxString *arg3 = 0 ;
14578 int arg4 = (int) -1 ;
14579 bool result;
14580 void *argp1 = 0 ;
14581 int res1 = 0 ;
14582 bool temp2 = false ;
14583 bool temp3 = false ;
14584 int val4 ;
14585 int ecode4 = 0 ;
14586 PyObject * obj0 = 0 ;
14587 PyObject * obj1 = 0 ;
14588 PyObject * obj2 = 0 ;
14589 PyObject * obj3 = 0 ;
14590 char * kwnames[] = {
14591 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14592 };
14593
14594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14596 if (!SWIG_IsOK(res1)) {
14597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14598 }
14599 arg1 = reinterpret_cast< wxImage * >(argp1);
14600 {
14601 arg2 = wxString_in_helper(obj1);
14602 if (arg2 == NULL) SWIG_fail;
14603 temp2 = true;
14604 }
14605 {
14606 arg3 = wxString_in_helper(obj2);
14607 if (arg3 == NULL) SWIG_fail;
14608 temp3 = true;
14609 }
14610 if (obj3) {
14611 ecode4 = SWIG_AsVal_int(obj3, &val4);
14612 if (!SWIG_IsOK(ecode4)) {
14613 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14614 }
14615 arg4 = static_cast< int >(val4);
14616 }
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14620 wxPyEndAllowThreads(__tstate);
14621 if (PyErr_Occurred()) SWIG_fail;
14622 }
14623 {
14624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14625 }
14626 {
14627 if (temp2)
14628 delete arg2;
14629 }
14630 {
14631 if (temp3)
14632 delete arg3;
14633 }
14634 return resultobj;
14635 fail:
14636 {
14637 if (temp2)
14638 delete arg2;
14639 }
14640 {
14641 if (temp3)
14642 delete arg3;
14643 }
14644 return NULL;
14645 }
14646
14647
14648 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14649 PyObject *resultobj = 0;
14650 wxImage *arg1 = (wxImage *) 0 ;
14651 wxString *arg2 = 0 ;
14652 int arg3 ;
14653 bool result;
14654 void *argp1 = 0 ;
14655 int res1 = 0 ;
14656 bool temp2 = false ;
14657 int val3 ;
14658 int ecode3 = 0 ;
14659 PyObject * obj0 = 0 ;
14660 PyObject * obj1 = 0 ;
14661 PyObject * obj2 = 0 ;
14662 char * kwnames[] = {
14663 (char *) "self",(char *) "name",(char *) "type", NULL
14664 };
14665
14666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14668 if (!SWIG_IsOK(res1)) {
14669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14670 }
14671 arg1 = reinterpret_cast< wxImage * >(argp1);
14672 {
14673 arg2 = wxString_in_helper(obj1);
14674 if (arg2 == NULL) SWIG_fail;
14675 temp2 = true;
14676 }
14677 ecode3 = SWIG_AsVal_int(obj2, &val3);
14678 if (!SWIG_IsOK(ecode3)) {
14679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14680 }
14681 arg3 = static_cast< int >(val3);
14682 {
14683 PyThreadState* __tstate = wxPyBeginAllowThreads();
14684 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14685 wxPyEndAllowThreads(__tstate);
14686 if (PyErr_Occurred()) SWIG_fail;
14687 }
14688 {
14689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14690 }
14691 {
14692 if (temp2)
14693 delete arg2;
14694 }
14695 return resultobj;
14696 fail:
14697 {
14698 if (temp2)
14699 delete arg2;
14700 }
14701 return NULL;
14702 }
14703
14704
14705 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14706 PyObject *resultobj = 0;
14707 wxImage *arg1 = (wxImage *) 0 ;
14708 wxString *arg2 = 0 ;
14709 wxString *arg3 = 0 ;
14710 bool result;
14711 void *argp1 = 0 ;
14712 int res1 = 0 ;
14713 bool temp2 = false ;
14714 bool temp3 = false ;
14715 PyObject * obj0 = 0 ;
14716 PyObject * obj1 = 0 ;
14717 PyObject * obj2 = 0 ;
14718 char * kwnames[] = {
14719 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14720 };
14721
14722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14724 if (!SWIG_IsOK(res1)) {
14725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14726 }
14727 arg1 = reinterpret_cast< wxImage * >(argp1);
14728 {
14729 arg2 = wxString_in_helper(obj1);
14730 if (arg2 == NULL) SWIG_fail;
14731 temp2 = true;
14732 }
14733 {
14734 arg3 = wxString_in_helper(obj2);
14735 if (arg3 == NULL) SWIG_fail;
14736 temp3 = true;
14737 }
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 {
14745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14746 }
14747 {
14748 if (temp2)
14749 delete arg2;
14750 }
14751 {
14752 if (temp3)
14753 delete arg3;
14754 }
14755 return resultobj;
14756 fail:
14757 {
14758 if (temp2)
14759 delete arg2;
14760 }
14761 {
14762 if (temp3)
14763 delete arg3;
14764 }
14765 return NULL;
14766 }
14767
14768
14769 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14770 PyObject *resultobj = 0;
14771 wxInputStream *arg1 = 0 ;
14772 bool result;
14773 wxPyInputStream *temp1 ;
14774 bool created1 ;
14775 PyObject * obj0 = 0 ;
14776 char * kwnames[] = {
14777 (char *) "stream", NULL
14778 };
14779
14780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14781 {
14782 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14783 arg1 = temp1->m_wxis;
14784 created1 = false;
14785 } else {
14786 PyErr_Clear(); // clear the failure of the wxPyConvert above
14787 arg1 = wxPyCBInputStream_create(obj0, false);
14788 if (arg1 == NULL) {
14789 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14790 SWIG_fail;
14791 }
14792 created1 = true;
14793 }
14794 }
14795 {
14796 PyThreadState* __tstate = wxPyBeginAllowThreads();
14797 result = (bool)wxImage::CanRead(*arg1);
14798 wxPyEndAllowThreads(__tstate);
14799 if (PyErr_Occurred()) SWIG_fail;
14800 }
14801 {
14802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14803 }
14804 {
14805 if (created1) delete arg1;
14806 }
14807 return resultobj;
14808 fail:
14809 {
14810 if (created1) delete arg1;
14811 }
14812 return NULL;
14813 }
14814
14815
14816 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14817 PyObject *resultobj = 0;
14818 wxImage *arg1 = (wxImage *) 0 ;
14819 wxInputStream *arg2 = 0 ;
14820 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14821 int arg4 = (int) -1 ;
14822 bool result;
14823 void *argp1 = 0 ;
14824 int res1 = 0 ;
14825 wxPyInputStream *temp2 ;
14826 bool created2 ;
14827 long val3 ;
14828 int ecode3 = 0 ;
14829 int val4 ;
14830 int ecode4 = 0 ;
14831 PyObject * obj0 = 0 ;
14832 PyObject * obj1 = 0 ;
14833 PyObject * obj2 = 0 ;
14834 PyObject * obj3 = 0 ;
14835 char * kwnames[] = {
14836 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14837 };
14838
14839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14841 if (!SWIG_IsOK(res1)) {
14842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14843 }
14844 arg1 = reinterpret_cast< wxImage * >(argp1);
14845 {
14846 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14847 arg2 = temp2->m_wxis;
14848 created2 = false;
14849 } else {
14850 PyErr_Clear(); // clear the failure of the wxPyConvert above
14851 arg2 = wxPyCBInputStream_create(obj1, false);
14852 if (arg2 == NULL) {
14853 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14854 SWIG_fail;
14855 }
14856 created2 = true;
14857 }
14858 }
14859 if (obj2) {
14860 ecode3 = SWIG_AsVal_long(obj2, &val3);
14861 if (!SWIG_IsOK(ecode3)) {
14862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14863 }
14864 arg3 = static_cast< long >(val3);
14865 }
14866 if (obj3) {
14867 ecode4 = SWIG_AsVal_int(obj3, &val4);
14868 if (!SWIG_IsOK(ecode4)) {
14869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14870 }
14871 arg4 = static_cast< int >(val4);
14872 }
14873 {
14874 PyThreadState* __tstate = wxPyBeginAllowThreads();
14875 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14876 wxPyEndAllowThreads(__tstate);
14877 if (PyErr_Occurred()) SWIG_fail;
14878 }
14879 {
14880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14881 }
14882 {
14883 if (created2) delete arg2;
14884 }
14885 return resultobj;
14886 fail:
14887 {
14888 if (created2) delete arg2;
14889 }
14890 return NULL;
14891 }
14892
14893
14894 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj = 0;
14896 wxImage *arg1 = (wxImage *) 0 ;
14897 wxInputStream *arg2 = 0 ;
14898 wxString *arg3 = 0 ;
14899 int arg4 = (int) -1 ;
14900 bool result;
14901 void *argp1 = 0 ;
14902 int res1 = 0 ;
14903 wxPyInputStream *temp2 ;
14904 bool created2 ;
14905 bool temp3 = false ;
14906 int val4 ;
14907 int ecode4 = 0 ;
14908 PyObject * obj0 = 0 ;
14909 PyObject * obj1 = 0 ;
14910 PyObject * obj2 = 0 ;
14911 PyObject * obj3 = 0 ;
14912 char * kwnames[] = {
14913 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14914 };
14915
14916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14918 if (!SWIG_IsOK(res1)) {
14919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14920 }
14921 arg1 = reinterpret_cast< wxImage * >(argp1);
14922 {
14923 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14924 arg2 = temp2->m_wxis;
14925 created2 = false;
14926 } else {
14927 PyErr_Clear(); // clear the failure of the wxPyConvert above
14928 arg2 = wxPyCBInputStream_create(obj1, false);
14929 if (arg2 == NULL) {
14930 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14931 SWIG_fail;
14932 }
14933 created2 = true;
14934 }
14935 }
14936 {
14937 arg3 = wxString_in_helper(obj2);
14938 if (arg3 == NULL) SWIG_fail;
14939 temp3 = true;
14940 }
14941 if (obj3) {
14942 ecode4 = SWIG_AsVal_int(obj3, &val4);
14943 if (!SWIG_IsOK(ecode4)) {
14944 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14945 }
14946 arg4 = static_cast< int >(val4);
14947 }
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14951 wxPyEndAllowThreads(__tstate);
14952 if (PyErr_Occurred()) SWIG_fail;
14953 }
14954 {
14955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14956 }
14957 {
14958 if (created2) delete arg2;
14959 }
14960 {
14961 if (temp3)
14962 delete arg3;
14963 }
14964 return resultobj;
14965 fail:
14966 {
14967 if (created2) delete arg2;
14968 }
14969 {
14970 if (temp3)
14971 delete arg3;
14972 }
14973 return NULL;
14974 }
14975
14976
14977 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14978 PyObject *resultobj = 0;
14979 wxImage *arg1 = (wxImage *) 0 ;
14980 bool result;
14981 void *argp1 = 0 ;
14982 int res1 = 0 ;
14983 PyObject *swig_obj[1] ;
14984
14985 if (!args) SWIG_fail;
14986 swig_obj[0] = args;
14987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14988 if (!SWIG_IsOK(res1)) {
14989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14990 }
14991 arg1 = reinterpret_cast< wxImage * >(argp1);
14992 {
14993 PyThreadState* __tstate = wxPyBeginAllowThreads();
14994 result = (bool)(arg1)->Ok();
14995 wxPyEndAllowThreads(__tstate);
14996 if (PyErr_Occurred()) SWIG_fail;
14997 }
14998 {
14999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15000 }
15001 return resultobj;
15002 fail:
15003 return NULL;
15004 }
15005
15006
15007 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15008 PyObject *resultobj = 0;
15009 wxImage *arg1 = (wxImage *) 0 ;
15010 int result;
15011 void *argp1 = 0 ;
15012 int res1 = 0 ;
15013 PyObject *swig_obj[1] ;
15014
15015 if (!args) SWIG_fail;
15016 swig_obj[0] = args;
15017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15018 if (!SWIG_IsOK(res1)) {
15019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15020 }
15021 arg1 = reinterpret_cast< wxImage * >(argp1);
15022 {
15023 PyThreadState* __tstate = wxPyBeginAllowThreads();
15024 result = (int)(arg1)->GetWidth();
15025 wxPyEndAllowThreads(__tstate);
15026 if (PyErr_Occurred()) SWIG_fail;
15027 }
15028 resultobj = SWIG_From_int(static_cast< int >(result));
15029 return resultobj;
15030 fail:
15031 return NULL;
15032 }
15033
15034
15035 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15036 PyObject *resultobj = 0;
15037 wxImage *arg1 = (wxImage *) 0 ;
15038 int result;
15039 void *argp1 = 0 ;
15040 int res1 = 0 ;
15041 PyObject *swig_obj[1] ;
15042
15043 if (!args) SWIG_fail;
15044 swig_obj[0] = args;
15045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15046 if (!SWIG_IsOK(res1)) {
15047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15048 }
15049 arg1 = reinterpret_cast< wxImage * >(argp1);
15050 {
15051 PyThreadState* __tstate = wxPyBeginAllowThreads();
15052 result = (int)(arg1)->GetHeight();
15053 wxPyEndAllowThreads(__tstate);
15054 if (PyErr_Occurred()) SWIG_fail;
15055 }
15056 resultobj = SWIG_From_int(static_cast< int >(result));
15057 return resultobj;
15058 fail:
15059 return NULL;
15060 }
15061
15062
15063 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15064 PyObject *resultobj = 0;
15065 wxImage *arg1 = (wxImage *) 0 ;
15066 wxSize result;
15067 void *argp1 = 0 ;
15068 int res1 = 0 ;
15069 PyObject *swig_obj[1] ;
15070
15071 if (!args) SWIG_fail;
15072 swig_obj[0] = args;
15073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15074 if (!SWIG_IsOK(res1)) {
15075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15076 }
15077 arg1 = reinterpret_cast< wxImage * >(argp1);
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 result = wxImage_GetSize(arg1);
15081 wxPyEndAllowThreads(__tstate);
15082 if (PyErr_Occurred()) SWIG_fail;
15083 }
15084 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15085 return resultobj;
15086 fail:
15087 return NULL;
15088 }
15089
15090
15091 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15092 PyObject *resultobj = 0;
15093 wxImage *arg1 = (wxImage *) 0 ;
15094 wxRect *arg2 = 0 ;
15095 SwigValueWrapper<wxImage > result;
15096 void *argp1 = 0 ;
15097 int res1 = 0 ;
15098 wxRect temp2 ;
15099 PyObject * obj0 = 0 ;
15100 PyObject * obj1 = 0 ;
15101 char * kwnames[] = {
15102 (char *) "self",(char *) "rect", NULL
15103 };
15104
15105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15107 if (!SWIG_IsOK(res1)) {
15108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15109 }
15110 arg1 = reinterpret_cast< wxImage * >(argp1);
15111 {
15112 arg2 = &temp2;
15113 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15114 }
15115 {
15116 PyThreadState* __tstate = wxPyBeginAllowThreads();
15117 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15118 wxPyEndAllowThreads(__tstate);
15119 if (PyErr_Occurred()) SWIG_fail;
15120 }
15121 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15122 return resultobj;
15123 fail:
15124 return NULL;
15125 }
15126
15127
15128 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15129 PyObject *resultobj = 0;
15130 wxImage *arg1 = (wxImage *) 0 ;
15131 wxSize *arg2 = 0 ;
15132 wxPoint *arg3 = 0 ;
15133 int arg4 = (int) -1 ;
15134 int arg5 = (int) -1 ;
15135 int arg6 = (int) -1 ;
15136 SwigValueWrapper<wxImage > result;
15137 void *argp1 = 0 ;
15138 int res1 = 0 ;
15139 wxSize temp2 ;
15140 wxPoint temp3 ;
15141 int val4 ;
15142 int ecode4 = 0 ;
15143 int val5 ;
15144 int ecode5 = 0 ;
15145 int val6 ;
15146 int ecode6 = 0 ;
15147 PyObject * obj0 = 0 ;
15148 PyObject * obj1 = 0 ;
15149 PyObject * obj2 = 0 ;
15150 PyObject * obj3 = 0 ;
15151 PyObject * obj4 = 0 ;
15152 PyObject * obj5 = 0 ;
15153 char * kwnames[] = {
15154 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15155 };
15156
15157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15159 if (!SWIG_IsOK(res1)) {
15160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15161 }
15162 arg1 = reinterpret_cast< wxImage * >(argp1);
15163 {
15164 arg2 = &temp2;
15165 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15166 }
15167 {
15168 arg3 = &temp3;
15169 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15170 }
15171 if (obj3) {
15172 ecode4 = SWIG_AsVal_int(obj3, &val4);
15173 if (!SWIG_IsOK(ecode4)) {
15174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15175 }
15176 arg4 = static_cast< int >(val4);
15177 }
15178 if (obj4) {
15179 ecode5 = SWIG_AsVal_int(obj4, &val5);
15180 if (!SWIG_IsOK(ecode5)) {
15181 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15182 }
15183 arg5 = static_cast< int >(val5);
15184 }
15185 if (obj5) {
15186 ecode6 = SWIG_AsVal_int(obj5, &val6);
15187 if (!SWIG_IsOK(ecode6)) {
15188 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15189 }
15190 arg6 = static_cast< int >(val6);
15191 }
15192 {
15193 PyThreadState* __tstate = wxPyBeginAllowThreads();
15194 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15195 wxPyEndAllowThreads(__tstate);
15196 if (PyErr_Occurred()) SWIG_fail;
15197 }
15198 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15199 return resultobj;
15200 fail:
15201 return NULL;
15202 }
15203
15204
15205 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15206 PyObject *resultobj = 0;
15207 wxImage *arg1 = (wxImage *) 0 ;
15208 SwigValueWrapper<wxImage > result;
15209 void *argp1 = 0 ;
15210 int res1 = 0 ;
15211 PyObject *swig_obj[1] ;
15212
15213 if (!args) SWIG_fail;
15214 swig_obj[0] = args;
15215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15216 if (!SWIG_IsOK(res1)) {
15217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15218 }
15219 arg1 = reinterpret_cast< wxImage * >(argp1);
15220 {
15221 PyThreadState* __tstate = wxPyBeginAllowThreads();
15222 result = (arg1)->Copy();
15223 wxPyEndAllowThreads(__tstate);
15224 if (PyErr_Occurred()) SWIG_fail;
15225 }
15226 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15227 return resultobj;
15228 fail:
15229 return NULL;
15230 }
15231
15232
15233 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15234 PyObject *resultobj = 0;
15235 wxImage *arg1 = (wxImage *) 0 ;
15236 wxImage *arg2 = 0 ;
15237 int arg3 ;
15238 int arg4 ;
15239 void *argp1 = 0 ;
15240 int res1 = 0 ;
15241 void *argp2 = 0 ;
15242 int res2 = 0 ;
15243 int val3 ;
15244 int ecode3 = 0 ;
15245 int val4 ;
15246 int ecode4 = 0 ;
15247 PyObject * obj0 = 0 ;
15248 PyObject * obj1 = 0 ;
15249 PyObject * obj2 = 0 ;
15250 PyObject * obj3 = 0 ;
15251 char * kwnames[] = {
15252 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15253 };
15254
15255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15257 if (!SWIG_IsOK(res1)) {
15258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15259 }
15260 arg1 = reinterpret_cast< wxImage * >(argp1);
15261 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15262 if (!SWIG_IsOK(res2)) {
15263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15264 }
15265 if (!argp2) {
15266 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15267 }
15268 arg2 = reinterpret_cast< wxImage * >(argp2);
15269 ecode3 = SWIG_AsVal_int(obj2, &val3);
15270 if (!SWIG_IsOK(ecode3)) {
15271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15272 }
15273 arg3 = static_cast< int >(val3);
15274 ecode4 = SWIG_AsVal_int(obj3, &val4);
15275 if (!SWIG_IsOK(ecode4)) {
15276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15277 }
15278 arg4 = static_cast< int >(val4);
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15282 wxPyEndAllowThreads(__tstate);
15283 if (PyErr_Occurred()) SWIG_fail;
15284 }
15285 resultobj = SWIG_Py_Void();
15286 return resultobj;
15287 fail:
15288 return NULL;
15289 }
15290
15291
15292 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15293 PyObject *resultobj = 0;
15294 wxImage *arg1 = (wxImage *) 0 ;
15295 PyObject *result = 0 ;
15296 void *argp1 = 0 ;
15297 int res1 = 0 ;
15298 PyObject *swig_obj[1] ;
15299
15300 if (!args) SWIG_fail;
15301 swig_obj[0] = args;
15302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15303 if (!SWIG_IsOK(res1)) {
15304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15305 }
15306 arg1 = reinterpret_cast< wxImage * >(argp1);
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = (PyObject *)wxImage_GetData(arg1);
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 resultobj = result;
15314 return resultobj;
15315 fail:
15316 return NULL;
15317 }
15318
15319
15320 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15321 PyObject *resultobj = 0;
15322 wxImage *arg1 = (wxImage *) 0 ;
15323 buffer arg2 ;
15324 int arg3 ;
15325 void *argp1 = 0 ;
15326 int res1 = 0 ;
15327 PyObject * obj0 = 0 ;
15328 PyObject * obj1 = 0 ;
15329 char * kwnames[] = {
15330 (char *) "self",(char *) "data", NULL
15331 };
15332
15333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15335 if (!SWIG_IsOK(res1)) {
15336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15337 }
15338 arg1 = reinterpret_cast< wxImage * >(argp1);
15339 {
15340 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15341 }
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 wxImage_SetData(arg1,arg2,arg3);
15345 wxPyEndAllowThreads(__tstate);
15346 if (PyErr_Occurred()) SWIG_fail;
15347 }
15348 resultobj = SWIG_Py_Void();
15349 return resultobj;
15350 fail:
15351 return NULL;
15352 }
15353
15354
15355 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15356 PyObject *resultobj = 0;
15357 wxImage *arg1 = (wxImage *) 0 ;
15358 PyObject *result = 0 ;
15359 void *argp1 = 0 ;
15360 int res1 = 0 ;
15361 PyObject *swig_obj[1] ;
15362
15363 if (!args) SWIG_fail;
15364 swig_obj[0] = args;
15365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15366 if (!SWIG_IsOK(res1)) {
15367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15368 }
15369 arg1 = reinterpret_cast< wxImage * >(argp1);
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = result;
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15384 PyObject *resultobj = 0;
15385 wxImage *arg1 = (wxImage *) 0 ;
15386 buffer arg2 ;
15387 int arg3 ;
15388 void *argp1 = 0 ;
15389 int res1 = 0 ;
15390 PyObject * obj0 = 0 ;
15391 PyObject * obj1 = 0 ;
15392 char * kwnames[] = {
15393 (char *) "self",(char *) "data", NULL
15394 };
15395
15396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15398 if (!SWIG_IsOK(res1)) {
15399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15400 }
15401 arg1 = reinterpret_cast< wxImage * >(argp1);
15402 {
15403 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15404 }
15405 {
15406 PyThreadState* __tstate = wxPyBeginAllowThreads();
15407 wxImage_SetDataBuffer(arg1,arg2,arg3);
15408 wxPyEndAllowThreads(__tstate);
15409 if (PyErr_Occurred()) SWIG_fail;
15410 }
15411 resultobj = SWIG_Py_Void();
15412 return resultobj;
15413 fail:
15414 return NULL;
15415 }
15416
15417
15418 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15419 PyObject *resultobj = 0;
15420 wxImage *arg1 = (wxImage *) 0 ;
15421 PyObject *result = 0 ;
15422 void *argp1 = 0 ;
15423 int res1 = 0 ;
15424 PyObject *swig_obj[1] ;
15425
15426 if (!args) SWIG_fail;
15427 swig_obj[0] = args;
15428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15429 if (!SWIG_IsOK(res1)) {
15430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15431 }
15432 arg1 = reinterpret_cast< wxImage * >(argp1);
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 result = (PyObject *)wxImage_GetAlphaData(arg1);
15436 wxPyEndAllowThreads(__tstate);
15437 if (PyErr_Occurred()) SWIG_fail;
15438 }
15439 resultobj = result;
15440 return resultobj;
15441 fail:
15442 return NULL;
15443 }
15444
15445
15446 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15447 PyObject *resultobj = 0;
15448 wxImage *arg1 = (wxImage *) 0 ;
15449 buffer arg2 ;
15450 int arg3 ;
15451 void *argp1 = 0 ;
15452 int res1 = 0 ;
15453 PyObject * obj0 = 0 ;
15454 PyObject * obj1 = 0 ;
15455 char * kwnames[] = {
15456 (char *) "self",(char *) "alpha", NULL
15457 };
15458
15459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15461 if (!SWIG_IsOK(res1)) {
15462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15463 }
15464 arg1 = reinterpret_cast< wxImage * >(argp1);
15465 {
15466 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15467 }
15468 {
15469 PyThreadState* __tstate = wxPyBeginAllowThreads();
15470 wxImage_SetAlphaData(arg1,arg2,arg3);
15471 wxPyEndAllowThreads(__tstate);
15472 if (PyErr_Occurred()) SWIG_fail;
15473 }
15474 resultobj = SWIG_Py_Void();
15475 return resultobj;
15476 fail:
15477 return NULL;
15478 }
15479
15480
15481 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15482 PyObject *resultobj = 0;
15483 wxImage *arg1 = (wxImage *) 0 ;
15484 PyObject *result = 0 ;
15485 void *argp1 = 0 ;
15486 int res1 = 0 ;
15487 PyObject *swig_obj[1] ;
15488
15489 if (!args) SWIG_fail;
15490 swig_obj[0] = args;
15491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15492 if (!SWIG_IsOK(res1)) {
15493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15494 }
15495 arg1 = reinterpret_cast< wxImage * >(argp1);
15496 {
15497 PyThreadState* __tstate = wxPyBeginAllowThreads();
15498 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15499 wxPyEndAllowThreads(__tstate);
15500 if (PyErr_Occurred()) SWIG_fail;
15501 }
15502 resultobj = result;
15503 return resultobj;
15504 fail:
15505 return NULL;
15506 }
15507
15508
15509 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15510 PyObject *resultobj = 0;
15511 wxImage *arg1 = (wxImage *) 0 ;
15512 buffer arg2 ;
15513 int arg3 ;
15514 void *argp1 = 0 ;
15515 int res1 = 0 ;
15516 PyObject * obj0 = 0 ;
15517 PyObject * obj1 = 0 ;
15518 char * kwnames[] = {
15519 (char *) "self",(char *) "alpha", NULL
15520 };
15521
15522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15524 if (!SWIG_IsOK(res1)) {
15525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15526 }
15527 arg1 = reinterpret_cast< wxImage * >(argp1);
15528 {
15529 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15530 }
15531 {
15532 PyThreadState* __tstate = wxPyBeginAllowThreads();
15533 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15534 wxPyEndAllowThreads(__tstate);
15535 if (PyErr_Occurred()) SWIG_fail;
15536 }
15537 resultobj = SWIG_Py_Void();
15538 return resultobj;
15539 fail:
15540 return NULL;
15541 }
15542
15543
15544 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15545 PyObject *resultobj = 0;
15546 wxImage *arg1 = (wxImage *) 0 ;
15547 byte arg2 ;
15548 byte arg3 ;
15549 byte arg4 ;
15550 void *argp1 = 0 ;
15551 int res1 = 0 ;
15552 unsigned char val2 ;
15553 int ecode2 = 0 ;
15554 unsigned char val3 ;
15555 int ecode3 = 0 ;
15556 unsigned char val4 ;
15557 int ecode4 = 0 ;
15558 PyObject * obj0 = 0 ;
15559 PyObject * obj1 = 0 ;
15560 PyObject * obj2 = 0 ;
15561 PyObject * obj3 = 0 ;
15562 char * kwnames[] = {
15563 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15564 };
15565
15566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15570 }
15571 arg1 = reinterpret_cast< wxImage * >(argp1);
15572 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15573 if (!SWIG_IsOK(ecode2)) {
15574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15575 }
15576 arg2 = static_cast< byte >(val2);
15577 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15578 if (!SWIG_IsOK(ecode3)) {
15579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15580 }
15581 arg3 = static_cast< byte >(val3);
15582 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15583 if (!SWIG_IsOK(ecode4)) {
15584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15585 }
15586 arg4 = static_cast< byte >(val4);
15587 {
15588 PyThreadState* __tstate = wxPyBeginAllowThreads();
15589 (arg1)->SetMaskColour(arg2,arg3,arg4);
15590 wxPyEndAllowThreads(__tstate);
15591 if (PyErr_Occurred()) SWIG_fail;
15592 }
15593 resultobj = SWIG_Py_Void();
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15601 PyObject *resultobj = 0;
15602 wxImage *arg1 = (wxImage *) 0 ;
15603 byte *arg2 = (byte *) 0 ;
15604 byte *arg3 = (byte *) 0 ;
15605 byte *arg4 = (byte *) 0 ;
15606 void *argp1 = 0 ;
15607 int res1 = 0 ;
15608 byte temp2 ;
15609 int res2 = SWIG_TMPOBJ ;
15610 byte temp3 ;
15611 int res3 = SWIG_TMPOBJ ;
15612 byte temp4 ;
15613 int res4 = SWIG_TMPOBJ ;
15614 PyObject *swig_obj[1] ;
15615
15616 arg2 = &temp2;
15617 arg3 = &temp3;
15618 arg4 = &temp4;
15619 if (!args) SWIG_fail;
15620 swig_obj[0] = args;
15621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15622 if (!SWIG_IsOK(res1)) {
15623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15624 }
15625 arg1 = reinterpret_cast< wxImage * >(argp1);
15626 {
15627 PyThreadState* __tstate = wxPyBeginAllowThreads();
15628 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15629 wxPyEndAllowThreads(__tstate);
15630 if (PyErr_Occurred()) SWIG_fail;
15631 }
15632 resultobj = SWIG_Py_Void();
15633 if (SWIG_IsTmpObj(res2)) {
15634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15635 } else {
15636 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15638 }
15639 if (SWIG_IsTmpObj(res3)) {
15640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15641 } else {
15642 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15644 }
15645 if (SWIG_IsTmpObj(res4)) {
15646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15647 } else {
15648 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15650 }
15651 return resultobj;
15652 fail:
15653 return NULL;
15654 }
15655
15656
15657 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15658 PyObject *resultobj = 0;
15659 wxImage *arg1 = (wxImage *) 0 ;
15660 byte result;
15661 void *argp1 = 0 ;
15662 int res1 = 0 ;
15663 PyObject *swig_obj[1] ;
15664
15665 if (!args) SWIG_fail;
15666 swig_obj[0] = args;
15667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15668 if (!SWIG_IsOK(res1)) {
15669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15670 }
15671 arg1 = reinterpret_cast< wxImage * >(argp1);
15672 {
15673 PyThreadState* __tstate = wxPyBeginAllowThreads();
15674 result = (byte)(arg1)->GetMaskRed();
15675 wxPyEndAllowThreads(__tstate);
15676 if (PyErr_Occurred()) SWIG_fail;
15677 }
15678 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15679 return resultobj;
15680 fail:
15681 return NULL;
15682 }
15683
15684
15685 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15686 PyObject *resultobj = 0;
15687 wxImage *arg1 = (wxImage *) 0 ;
15688 byte result;
15689 void *argp1 = 0 ;
15690 int res1 = 0 ;
15691 PyObject *swig_obj[1] ;
15692
15693 if (!args) SWIG_fail;
15694 swig_obj[0] = args;
15695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15696 if (!SWIG_IsOK(res1)) {
15697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15698 }
15699 arg1 = reinterpret_cast< wxImage * >(argp1);
15700 {
15701 PyThreadState* __tstate = wxPyBeginAllowThreads();
15702 result = (byte)(arg1)->GetMaskGreen();
15703 wxPyEndAllowThreads(__tstate);
15704 if (PyErr_Occurred()) SWIG_fail;
15705 }
15706 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15707 return resultobj;
15708 fail:
15709 return NULL;
15710 }
15711
15712
15713 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15714 PyObject *resultobj = 0;
15715 wxImage *arg1 = (wxImage *) 0 ;
15716 byte result;
15717 void *argp1 = 0 ;
15718 int res1 = 0 ;
15719 PyObject *swig_obj[1] ;
15720
15721 if (!args) SWIG_fail;
15722 swig_obj[0] = args;
15723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15724 if (!SWIG_IsOK(res1)) {
15725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15726 }
15727 arg1 = reinterpret_cast< wxImage * >(argp1);
15728 {
15729 PyThreadState* __tstate = wxPyBeginAllowThreads();
15730 result = (byte)(arg1)->GetMaskBlue();
15731 wxPyEndAllowThreads(__tstate);
15732 if (PyErr_Occurred()) SWIG_fail;
15733 }
15734 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15735 return resultobj;
15736 fail:
15737 return NULL;
15738 }
15739
15740
15741 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15742 PyObject *resultobj = 0;
15743 wxImage *arg1 = (wxImage *) 0 ;
15744 bool arg2 = (bool) true ;
15745 void *argp1 = 0 ;
15746 int res1 = 0 ;
15747 bool val2 ;
15748 int ecode2 = 0 ;
15749 PyObject * obj0 = 0 ;
15750 PyObject * obj1 = 0 ;
15751 char * kwnames[] = {
15752 (char *) "self",(char *) "mask", NULL
15753 };
15754
15755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15757 if (!SWIG_IsOK(res1)) {
15758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15759 }
15760 arg1 = reinterpret_cast< wxImage * >(argp1);
15761 if (obj1) {
15762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15763 if (!SWIG_IsOK(ecode2)) {
15764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15765 }
15766 arg2 = static_cast< bool >(val2);
15767 }
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 (arg1)->SetMask(arg2);
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 resultobj = SWIG_Py_Void();
15775 return resultobj;
15776 fail:
15777 return NULL;
15778 }
15779
15780
15781 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15782 PyObject *resultobj = 0;
15783 wxImage *arg1 = (wxImage *) 0 ;
15784 bool result;
15785 void *argp1 = 0 ;
15786 int res1 = 0 ;
15787 PyObject *swig_obj[1] ;
15788
15789 if (!args) SWIG_fail;
15790 swig_obj[0] = args;
15791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15792 if (!SWIG_IsOK(res1)) {
15793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15794 }
15795 arg1 = reinterpret_cast< wxImage * >(argp1);
15796 {
15797 PyThreadState* __tstate = wxPyBeginAllowThreads();
15798 result = (bool)(arg1)->HasMask();
15799 wxPyEndAllowThreads(__tstate);
15800 if (PyErr_Occurred()) SWIG_fail;
15801 }
15802 {
15803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15804 }
15805 return resultobj;
15806 fail:
15807 return NULL;
15808 }
15809
15810
15811 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15812 PyObject *resultobj = 0;
15813 wxImage *arg1 = (wxImage *) 0 ;
15814 double arg2 ;
15815 wxPoint *arg3 = 0 ;
15816 bool arg4 = (bool) true ;
15817 wxPoint *arg5 = (wxPoint *) NULL ;
15818 SwigValueWrapper<wxImage > result;
15819 void *argp1 = 0 ;
15820 int res1 = 0 ;
15821 double val2 ;
15822 int ecode2 = 0 ;
15823 wxPoint temp3 ;
15824 bool val4 ;
15825 int ecode4 = 0 ;
15826 void *argp5 = 0 ;
15827 int res5 = 0 ;
15828 PyObject * obj0 = 0 ;
15829 PyObject * obj1 = 0 ;
15830 PyObject * obj2 = 0 ;
15831 PyObject * obj3 = 0 ;
15832 PyObject * obj4 = 0 ;
15833 char * kwnames[] = {
15834 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15835 };
15836
15837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15839 if (!SWIG_IsOK(res1)) {
15840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15841 }
15842 arg1 = reinterpret_cast< wxImage * >(argp1);
15843 ecode2 = SWIG_AsVal_double(obj1, &val2);
15844 if (!SWIG_IsOK(ecode2)) {
15845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15846 }
15847 arg2 = static_cast< double >(val2);
15848 {
15849 arg3 = &temp3;
15850 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15851 }
15852 if (obj3) {
15853 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15854 if (!SWIG_IsOK(ecode4)) {
15855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15856 }
15857 arg4 = static_cast< bool >(val4);
15858 }
15859 if (obj4) {
15860 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15861 if (!SWIG_IsOK(res5)) {
15862 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15863 }
15864 arg5 = reinterpret_cast< wxPoint * >(argp5);
15865 }
15866 {
15867 PyThreadState* __tstate = wxPyBeginAllowThreads();
15868 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15869 wxPyEndAllowThreads(__tstate);
15870 if (PyErr_Occurred()) SWIG_fail;
15871 }
15872 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15873 return resultobj;
15874 fail:
15875 return NULL;
15876 }
15877
15878
15879 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15880 PyObject *resultobj = 0;
15881 wxImage *arg1 = (wxImage *) 0 ;
15882 bool arg2 = (bool) true ;
15883 SwigValueWrapper<wxImage > result;
15884 void *argp1 = 0 ;
15885 int res1 = 0 ;
15886 bool val2 ;
15887 int ecode2 = 0 ;
15888 PyObject * obj0 = 0 ;
15889 PyObject * obj1 = 0 ;
15890 char * kwnames[] = {
15891 (char *) "self",(char *) "clockwise", NULL
15892 };
15893
15894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15896 if (!SWIG_IsOK(res1)) {
15897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15898 }
15899 arg1 = reinterpret_cast< wxImage * >(argp1);
15900 if (obj1) {
15901 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15902 if (!SWIG_IsOK(ecode2)) {
15903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15904 }
15905 arg2 = static_cast< bool >(val2);
15906 }
15907 {
15908 PyThreadState* __tstate = wxPyBeginAllowThreads();
15909 result = (arg1)->Rotate90(arg2);
15910 wxPyEndAllowThreads(__tstate);
15911 if (PyErr_Occurred()) SWIG_fail;
15912 }
15913 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15914 return resultobj;
15915 fail:
15916 return NULL;
15917 }
15918
15919
15920 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15921 PyObject *resultobj = 0;
15922 wxImage *arg1 = (wxImage *) 0 ;
15923 bool arg2 = (bool) true ;
15924 SwigValueWrapper<wxImage > result;
15925 void *argp1 = 0 ;
15926 int res1 = 0 ;
15927 bool val2 ;
15928 int ecode2 = 0 ;
15929 PyObject * obj0 = 0 ;
15930 PyObject * obj1 = 0 ;
15931 char * kwnames[] = {
15932 (char *) "self",(char *) "horizontally", NULL
15933 };
15934
15935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15937 if (!SWIG_IsOK(res1)) {
15938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15939 }
15940 arg1 = reinterpret_cast< wxImage * >(argp1);
15941 if (obj1) {
15942 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15943 if (!SWIG_IsOK(ecode2)) {
15944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15945 }
15946 arg2 = static_cast< bool >(val2);
15947 }
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (arg1)->Mirror(arg2);
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15962 PyObject *resultobj = 0;
15963 wxImage *arg1 = (wxImage *) 0 ;
15964 byte arg2 ;
15965 byte arg3 ;
15966 byte arg4 ;
15967 byte arg5 ;
15968 byte arg6 ;
15969 byte arg7 ;
15970 void *argp1 = 0 ;
15971 int res1 = 0 ;
15972 unsigned char val2 ;
15973 int ecode2 = 0 ;
15974 unsigned char val3 ;
15975 int ecode3 = 0 ;
15976 unsigned char val4 ;
15977 int ecode4 = 0 ;
15978 unsigned char val5 ;
15979 int ecode5 = 0 ;
15980 unsigned char val6 ;
15981 int ecode6 = 0 ;
15982 unsigned char val7 ;
15983 int ecode7 = 0 ;
15984 PyObject * obj0 = 0 ;
15985 PyObject * obj1 = 0 ;
15986 PyObject * obj2 = 0 ;
15987 PyObject * obj3 = 0 ;
15988 PyObject * obj4 = 0 ;
15989 PyObject * obj5 = 0 ;
15990 PyObject * obj6 = 0 ;
15991 char * kwnames[] = {
15992 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15993 };
15994
15995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15997 if (!SWIG_IsOK(res1)) {
15998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15999 }
16000 arg1 = reinterpret_cast< wxImage * >(argp1);
16001 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16002 if (!SWIG_IsOK(ecode2)) {
16003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16004 }
16005 arg2 = static_cast< byte >(val2);
16006 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16007 if (!SWIG_IsOK(ecode3)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16009 }
16010 arg3 = static_cast< byte >(val3);
16011 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16012 if (!SWIG_IsOK(ecode4)) {
16013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16014 }
16015 arg4 = static_cast< byte >(val4);
16016 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16017 if (!SWIG_IsOK(ecode5)) {
16018 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16019 }
16020 arg5 = static_cast< byte >(val5);
16021 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16022 if (!SWIG_IsOK(ecode6)) {
16023 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16024 }
16025 arg6 = static_cast< byte >(val6);
16026 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16027 if (!SWIG_IsOK(ecode7)) {
16028 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16029 }
16030 arg7 = static_cast< byte >(val7);
16031 {
16032 PyThreadState* __tstate = wxPyBeginAllowThreads();
16033 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16034 wxPyEndAllowThreads(__tstate);
16035 if (PyErr_Occurred()) SWIG_fail;
16036 }
16037 resultobj = SWIG_Py_Void();
16038 return resultobj;
16039 fail:
16040 return NULL;
16041 }
16042
16043
16044 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16045 PyObject *resultobj = 0;
16046 wxImage *arg1 = (wxImage *) 0 ;
16047 double arg2 = (double) 0.299 ;
16048 double arg3 = (double) 0.587 ;
16049 double arg4 = (double) 0.114 ;
16050 SwigValueWrapper<wxImage > result;
16051 void *argp1 = 0 ;
16052 int res1 = 0 ;
16053 double val2 ;
16054 int ecode2 = 0 ;
16055 double val3 ;
16056 int ecode3 = 0 ;
16057 double val4 ;
16058 int ecode4 = 0 ;
16059 PyObject * obj0 = 0 ;
16060 PyObject * obj1 = 0 ;
16061 PyObject * obj2 = 0 ;
16062 PyObject * obj3 = 0 ;
16063 char * kwnames[] = {
16064 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16065 };
16066
16067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16069 if (!SWIG_IsOK(res1)) {
16070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16071 }
16072 arg1 = reinterpret_cast< wxImage * >(argp1);
16073 if (obj1) {
16074 ecode2 = SWIG_AsVal_double(obj1, &val2);
16075 if (!SWIG_IsOK(ecode2)) {
16076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16077 }
16078 arg2 = static_cast< double >(val2);
16079 }
16080 if (obj2) {
16081 ecode3 = SWIG_AsVal_double(obj2, &val3);
16082 if (!SWIG_IsOK(ecode3)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16084 }
16085 arg3 = static_cast< double >(val3);
16086 }
16087 if (obj3) {
16088 ecode4 = SWIG_AsVal_double(obj3, &val4);
16089 if (!SWIG_IsOK(ecode4)) {
16090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16091 }
16092 arg4 = static_cast< double >(val4);
16093 }
16094 {
16095 PyThreadState* __tstate = wxPyBeginAllowThreads();
16096 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
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_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16108 PyObject *resultobj = 0;
16109 wxImage *arg1 = (wxImage *) 0 ;
16110 byte arg2 ;
16111 byte arg3 ;
16112 byte arg4 ;
16113 SwigValueWrapper<wxImage > result;
16114 void *argp1 = 0 ;
16115 int res1 = 0 ;
16116 unsigned char val2 ;
16117 int ecode2 = 0 ;
16118 unsigned char val3 ;
16119 int ecode3 = 0 ;
16120 unsigned char val4 ;
16121 int ecode4 = 0 ;
16122 PyObject * obj0 = 0 ;
16123 PyObject * obj1 = 0 ;
16124 PyObject * obj2 = 0 ;
16125 PyObject * obj3 = 0 ;
16126 char * kwnames[] = {
16127 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16128 };
16129
16130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16132 if (!SWIG_IsOK(res1)) {
16133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16134 }
16135 arg1 = reinterpret_cast< wxImage * >(argp1);
16136 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16137 if (!SWIG_IsOK(ecode2)) {
16138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16139 }
16140 arg2 = static_cast< byte >(val2);
16141 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16142 if (!SWIG_IsOK(ecode3)) {
16143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16144 }
16145 arg3 = static_cast< byte >(val3);
16146 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16147 if (!SWIG_IsOK(ecode4)) {
16148 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16149 }
16150 arg4 = static_cast< byte >(val4);
16151 {
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16154 wxPyEndAllowThreads(__tstate);
16155 if (PyErr_Occurred()) SWIG_fail;
16156 }
16157 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16158 return resultobj;
16159 fail:
16160 return NULL;
16161 }
16162
16163
16164 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16165 PyObject *resultobj = 0;
16166 wxImage *arg1 = (wxImage *) 0 ;
16167 wxString *arg2 = 0 ;
16168 wxString *arg3 = 0 ;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 bool temp2 = false ;
16172 bool temp3 = false ;
16173 PyObject * obj0 = 0 ;
16174 PyObject * obj1 = 0 ;
16175 PyObject * obj2 = 0 ;
16176 char * kwnames[] = {
16177 (char *) "self",(char *) "name",(char *) "value", NULL
16178 };
16179
16180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16182 if (!SWIG_IsOK(res1)) {
16183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16184 }
16185 arg1 = reinterpret_cast< wxImage * >(argp1);
16186 {
16187 arg2 = wxString_in_helper(obj1);
16188 if (arg2 == NULL) SWIG_fail;
16189 temp2 = true;
16190 }
16191 {
16192 arg3 = wxString_in_helper(obj2);
16193 if (arg3 == NULL) SWIG_fail;
16194 temp3 = true;
16195 }
16196 {
16197 PyThreadState* __tstate = wxPyBeginAllowThreads();
16198 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16199 wxPyEndAllowThreads(__tstate);
16200 if (PyErr_Occurred()) SWIG_fail;
16201 }
16202 resultobj = SWIG_Py_Void();
16203 {
16204 if (temp2)
16205 delete arg2;
16206 }
16207 {
16208 if (temp3)
16209 delete arg3;
16210 }
16211 return resultobj;
16212 fail:
16213 {
16214 if (temp2)
16215 delete arg2;
16216 }
16217 {
16218 if (temp3)
16219 delete arg3;
16220 }
16221 return NULL;
16222 }
16223
16224
16225 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16226 PyObject *resultobj = 0;
16227 wxImage *arg1 = (wxImage *) 0 ;
16228 wxString *arg2 = 0 ;
16229 int arg3 ;
16230 void *argp1 = 0 ;
16231 int res1 = 0 ;
16232 bool temp2 = false ;
16233 int val3 ;
16234 int ecode3 = 0 ;
16235 PyObject * obj0 = 0 ;
16236 PyObject * obj1 = 0 ;
16237 PyObject * obj2 = 0 ;
16238 char * kwnames[] = {
16239 (char *) "self",(char *) "name",(char *) "value", NULL
16240 };
16241
16242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16244 if (!SWIG_IsOK(res1)) {
16245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16246 }
16247 arg1 = reinterpret_cast< wxImage * >(argp1);
16248 {
16249 arg2 = wxString_in_helper(obj1);
16250 if (arg2 == NULL) SWIG_fail;
16251 temp2 = true;
16252 }
16253 ecode3 = SWIG_AsVal_int(obj2, &val3);
16254 if (!SWIG_IsOK(ecode3)) {
16255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16256 }
16257 arg3 = static_cast< int >(val3);
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 (arg1)->SetOption((wxString const &)*arg2,arg3);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_Py_Void();
16265 {
16266 if (temp2)
16267 delete arg2;
16268 }
16269 return resultobj;
16270 fail:
16271 {
16272 if (temp2)
16273 delete arg2;
16274 }
16275 return NULL;
16276 }
16277
16278
16279 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj = 0;
16281 wxImage *arg1 = (wxImage *) 0 ;
16282 wxString *arg2 = 0 ;
16283 wxString result;
16284 void *argp1 = 0 ;
16285 int res1 = 0 ;
16286 bool temp2 = false ;
16287 PyObject * obj0 = 0 ;
16288 PyObject * obj1 = 0 ;
16289 char * kwnames[] = {
16290 (char *) "self",(char *) "name", NULL
16291 };
16292
16293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16297 }
16298 arg1 = reinterpret_cast< wxImage * >(argp1);
16299 {
16300 arg2 = wxString_in_helper(obj1);
16301 if (arg2 == NULL) SWIG_fail;
16302 temp2 = true;
16303 }
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 {
16311 #if wxUSE_UNICODE
16312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16313 #else
16314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16315 #endif
16316 }
16317 {
16318 if (temp2)
16319 delete arg2;
16320 }
16321 return resultobj;
16322 fail:
16323 {
16324 if (temp2)
16325 delete arg2;
16326 }
16327 return NULL;
16328 }
16329
16330
16331 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16332 PyObject *resultobj = 0;
16333 wxImage *arg1 = (wxImage *) 0 ;
16334 wxString *arg2 = 0 ;
16335 int result;
16336 void *argp1 = 0 ;
16337 int res1 = 0 ;
16338 bool temp2 = false ;
16339 PyObject * obj0 = 0 ;
16340 PyObject * obj1 = 0 ;
16341 char * kwnames[] = {
16342 (char *) "self",(char *) "name", NULL
16343 };
16344
16345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16347 if (!SWIG_IsOK(res1)) {
16348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16349 }
16350 arg1 = reinterpret_cast< wxImage * >(argp1);
16351 {
16352 arg2 = wxString_in_helper(obj1);
16353 if (arg2 == NULL) SWIG_fail;
16354 temp2 = true;
16355 }
16356 {
16357 PyThreadState* __tstate = wxPyBeginAllowThreads();
16358 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 resultobj = SWIG_From_int(static_cast< int >(result));
16363 {
16364 if (temp2)
16365 delete arg2;
16366 }
16367 return resultobj;
16368 fail:
16369 {
16370 if (temp2)
16371 delete arg2;
16372 }
16373 return NULL;
16374 }
16375
16376
16377 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16378 PyObject *resultobj = 0;
16379 wxImage *arg1 = (wxImage *) 0 ;
16380 wxString *arg2 = 0 ;
16381 bool result;
16382 void *argp1 = 0 ;
16383 int res1 = 0 ;
16384 bool temp2 = false ;
16385 PyObject * obj0 = 0 ;
16386 PyObject * obj1 = 0 ;
16387 char * kwnames[] = {
16388 (char *) "self",(char *) "name", NULL
16389 };
16390
16391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16393 if (!SWIG_IsOK(res1)) {
16394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16395 }
16396 arg1 = reinterpret_cast< wxImage * >(argp1);
16397 {
16398 arg2 = wxString_in_helper(obj1);
16399 if (arg2 == NULL) SWIG_fail;
16400 temp2 = true;
16401 }
16402 {
16403 PyThreadState* __tstate = wxPyBeginAllowThreads();
16404 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16405 wxPyEndAllowThreads(__tstate);
16406 if (PyErr_Occurred()) SWIG_fail;
16407 }
16408 {
16409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16410 }
16411 {
16412 if (temp2)
16413 delete arg2;
16414 }
16415 return resultobj;
16416 fail:
16417 {
16418 if (temp2)
16419 delete arg2;
16420 }
16421 return NULL;
16422 }
16423
16424
16425 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16426 PyObject *resultobj = 0;
16427 wxImage *arg1 = (wxImage *) 0 ;
16428 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16429 unsigned long result;
16430 void *argp1 = 0 ;
16431 int res1 = 0 ;
16432 unsigned long val2 ;
16433 int ecode2 = 0 ;
16434 PyObject * obj0 = 0 ;
16435 PyObject * obj1 = 0 ;
16436 char * kwnames[] = {
16437 (char *) "self",(char *) "stopafter", NULL
16438 };
16439
16440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16442 if (!SWIG_IsOK(res1)) {
16443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16444 }
16445 arg1 = reinterpret_cast< wxImage * >(argp1);
16446 if (obj1) {
16447 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16448 if (!SWIG_IsOK(ecode2)) {
16449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16450 }
16451 arg2 = static_cast< unsigned long >(val2);
16452 }
16453 {
16454 PyThreadState* __tstate = wxPyBeginAllowThreads();
16455 result = (unsigned long)(arg1)->CountColours(arg2);
16456 wxPyEndAllowThreads(__tstate);
16457 if (PyErr_Occurred()) SWIG_fail;
16458 }
16459 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16460 return resultobj;
16461 fail:
16462 return NULL;
16463 }
16464
16465
16466 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16467 PyObject *resultobj = 0;
16468 wxImage *arg1 = (wxImage *) 0 ;
16469 wxImageHistogram *arg2 = 0 ;
16470 unsigned long result;
16471 void *argp1 = 0 ;
16472 int res1 = 0 ;
16473 void *argp2 = 0 ;
16474 int res2 = 0 ;
16475 PyObject * obj0 = 0 ;
16476 PyObject * obj1 = 0 ;
16477 char * kwnames[] = {
16478 (char *) "self",(char *) "h", NULL
16479 };
16480
16481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16483 if (!SWIG_IsOK(res1)) {
16484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16485 }
16486 arg1 = reinterpret_cast< wxImage * >(argp1);
16487 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16488 if (!SWIG_IsOK(res2)) {
16489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16490 }
16491 if (!argp2) {
16492 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16493 }
16494 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16495 {
16496 PyThreadState* __tstate = wxPyBeginAllowThreads();
16497 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16502 return resultobj;
16503 fail:
16504 return NULL;
16505 }
16506
16507
16508 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16509 PyObject *resultobj = 0;
16510 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16511 void *argp1 = 0 ;
16512 int res1 = 0 ;
16513 PyObject * obj0 = 0 ;
16514 char * kwnames[] = {
16515 (char *) "handler", NULL
16516 };
16517
16518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16520 if (!SWIG_IsOK(res1)) {
16521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16522 }
16523 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16524 {
16525 PyThreadState* __tstate = wxPyBeginAllowThreads();
16526 wxImage::AddHandler(arg1);
16527 wxPyEndAllowThreads(__tstate);
16528 if (PyErr_Occurred()) SWIG_fail;
16529 }
16530 resultobj = SWIG_Py_Void();
16531 return resultobj;
16532 fail:
16533 return NULL;
16534 }
16535
16536
16537 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16538 PyObject *resultobj = 0;
16539 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16540 void *argp1 = 0 ;
16541 int res1 = 0 ;
16542 PyObject * obj0 = 0 ;
16543 char * kwnames[] = {
16544 (char *) "handler", NULL
16545 };
16546
16547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16549 if (!SWIG_IsOK(res1)) {
16550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16551 }
16552 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16553 {
16554 PyThreadState* __tstate = wxPyBeginAllowThreads();
16555 wxImage::InsertHandler(arg1);
16556 wxPyEndAllowThreads(__tstate);
16557 if (PyErr_Occurred()) SWIG_fail;
16558 }
16559 resultobj = SWIG_Py_Void();
16560 return resultobj;
16561 fail:
16562 return NULL;
16563 }
16564
16565
16566 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16567 PyObject *resultobj = 0;
16568 wxString *arg1 = 0 ;
16569 bool result;
16570 bool temp1 = false ;
16571 PyObject * obj0 = 0 ;
16572 char * kwnames[] = {
16573 (char *) "name", NULL
16574 };
16575
16576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16577 {
16578 arg1 = wxString_in_helper(obj0);
16579 if (arg1 == NULL) SWIG_fail;
16580 temp1 = true;
16581 }
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16585 wxPyEndAllowThreads(__tstate);
16586 if (PyErr_Occurred()) SWIG_fail;
16587 }
16588 {
16589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16590 }
16591 {
16592 if (temp1)
16593 delete arg1;
16594 }
16595 return resultobj;
16596 fail:
16597 {
16598 if (temp1)
16599 delete arg1;
16600 }
16601 return NULL;
16602 }
16603
16604
16605 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16606 PyObject *resultobj = 0;
16607 PyObject *result = 0 ;
16608
16609 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16610 {
16611 PyThreadState* __tstate = wxPyBeginAllowThreads();
16612 result = (PyObject *)wxImage_GetHandlers();
16613 wxPyEndAllowThreads(__tstate);
16614 if (PyErr_Occurred()) SWIG_fail;
16615 }
16616 resultobj = result;
16617 return resultobj;
16618 fail:
16619 return NULL;
16620 }
16621
16622
16623 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16624 PyObject *resultobj = 0;
16625 wxString result;
16626
16627 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16628 {
16629 PyThreadState* __tstate = wxPyBeginAllowThreads();
16630 result = wxImage::GetImageExtWildcard();
16631 wxPyEndAllowThreads(__tstate);
16632 if (PyErr_Occurred()) SWIG_fail;
16633 }
16634 {
16635 #if wxUSE_UNICODE
16636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16637 #else
16638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16639 #endif
16640 }
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj = 0;
16649 wxImage *arg1 = (wxImage *) 0 ;
16650 int arg2 = (int) -1 ;
16651 wxBitmap result;
16652 void *argp1 = 0 ;
16653 int res1 = 0 ;
16654 int val2 ;
16655 int ecode2 = 0 ;
16656 PyObject * obj0 = 0 ;
16657 PyObject * obj1 = 0 ;
16658 char * kwnames[] = {
16659 (char *) "self",(char *) "depth", NULL
16660 };
16661
16662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16664 if (!SWIG_IsOK(res1)) {
16665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16666 }
16667 arg1 = reinterpret_cast< wxImage * >(argp1);
16668 if (obj1) {
16669 ecode2 = SWIG_AsVal_int(obj1, &val2);
16670 if (!SWIG_IsOK(ecode2)) {
16671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16672 }
16673 arg2 = static_cast< int >(val2);
16674 }
16675 {
16676 if (!wxPyCheckForApp()) SWIG_fail;
16677 PyThreadState* __tstate = wxPyBeginAllowThreads();
16678 result = wxImage_ConvertToBitmap(arg1,arg2);
16679 wxPyEndAllowThreads(__tstate);
16680 if (PyErr_Occurred()) SWIG_fail;
16681 }
16682 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16683 return resultobj;
16684 fail:
16685 return NULL;
16686 }
16687
16688
16689 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16690 PyObject *resultobj = 0;
16691 wxImage *arg1 = (wxImage *) 0 ;
16692 byte arg2 ;
16693 byte arg3 ;
16694 byte arg4 ;
16695 wxBitmap result;
16696 void *argp1 = 0 ;
16697 int res1 = 0 ;
16698 unsigned char val2 ;
16699 int ecode2 = 0 ;
16700 unsigned char val3 ;
16701 int ecode3 = 0 ;
16702 unsigned char val4 ;
16703 int ecode4 = 0 ;
16704 PyObject * obj0 = 0 ;
16705 PyObject * obj1 = 0 ;
16706 PyObject * obj2 = 0 ;
16707 PyObject * obj3 = 0 ;
16708 char * kwnames[] = {
16709 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16710 };
16711
16712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16714 if (!SWIG_IsOK(res1)) {
16715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16716 }
16717 arg1 = reinterpret_cast< wxImage * >(argp1);
16718 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16719 if (!SWIG_IsOK(ecode2)) {
16720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16721 }
16722 arg2 = static_cast< byte >(val2);
16723 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16724 if (!SWIG_IsOK(ecode3)) {
16725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16726 }
16727 arg3 = static_cast< byte >(val3);
16728 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16729 if (!SWIG_IsOK(ecode4)) {
16730 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16731 }
16732 arg4 = static_cast< byte >(val4);
16733 {
16734 if (!wxPyCheckForApp()) SWIG_fail;
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16741 return resultobj;
16742 fail:
16743 return NULL;
16744 }
16745
16746
16747 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj = 0;
16749 wxImage *arg1 = (wxImage *) 0 ;
16750 double arg2 ;
16751 void *argp1 = 0 ;
16752 int res1 = 0 ;
16753 double val2 ;
16754 int ecode2 = 0 ;
16755 PyObject * obj0 = 0 ;
16756 PyObject * obj1 = 0 ;
16757 char * kwnames[] = {
16758 (char *) "self",(char *) "angle", NULL
16759 };
16760
16761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16763 if (!SWIG_IsOK(res1)) {
16764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16765 }
16766 arg1 = reinterpret_cast< wxImage * >(argp1);
16767 ecode2 = SWIG_AsVal_double(obj1, &val2);
16768 if (!SWIG_IsOK(ecode2)) {
16769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16770 }
16771 arg2 = static_cast< double >(val2);
16772 {
16773 PyThreadState* __tstate = wxPyBeginAllowThreads();
16774 (arg1)->RotateHue(arg2);
16775 wxPyEndAllowThreads(__tstate);
16776 if (PyErr_Occurred()) SWIG_fail;
16777 }
16778 resultobj = SWIG_Py_Void();
16779 return resultobj;
16780 fail:
16781 return NULL;
16782 }
16783
16784
16785 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16786 PyObject *resultobj = 0;
16787 wxImage_RGBValue arg1 ;
16788 wxImage_HSVValue result;
16789 void *argp1 ;
16790 int res1 = 0 ;
16791 PyObject * obj0 = 0 ;
16792 char * kwnames[] = {
16793 (char *) "rgb", NULL
16794 };
16795
16796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16797 {
16798 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16799 if (!SWIG_IsOK(res1)) {
16800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16801 }
16802 if (!argp1) {
16803 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16804 } else {
16805 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16806 arg1 = *temp;
16807 if (SWIG_IsNewObj(res1)) delete temp;
16808 }
16809 }
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 result = wxImage::RGBtoHSV(arg1);
16813 wxPyEndAllowThreads(__tstate);
16814 if (PyErr_Occurred()) SWIG_fail;
16815 }
16816 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16817 return resultobj;
16818 fail:
16819 return NULL;
16820 }
16821
16822
16823 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16824 PyObject *resultobj = 0;
16825 wxImage_HSVValue arg1 ;
16826 wxImage_RGBValue result;
16827 void *argp1 ;
16828 int res1 = 0 ;
16829 PyObject * obj0 = 0 ;
16830 char * kwnames[] = {
16831 (char *) "hsv", NULL
16832 };
16833
16834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16835 {
16836 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16837 if (!SWIG_IsOK(res1)) {
16838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16839 }
16840 if (!argp1) {
16841 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16842 } else {
16843 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16844 arg1 = *temp;
16845 if (SWIG_IsNewObj(res1)) delete temp;
16846 }
16847 }
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = wxImage::HSVtoRGB(arg1);
16851 wxPyEndAllowThreads(__tstate);
16852 if (PyErr_Occurred()) SWIG_fail;
16853 }
16854 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16862 PyObject *obj;
16863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16864 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16865 return SWIG_Py_Void();
16866 }
16867
16868 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16869 return SWIG_Python_InitShadowInstance(args);
16870 }
16871
16872 SWIGINTERN int NullImage_set(PyObject *) {
16873 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16874 return 1;
16875 }
16876
16877
16878 SWIGINTERN PyObject *NullImage_get(void) {
16879 PyObject *pyobj = 0;
16880
16881 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16882 return pyobj;
16883 }
16884
16885
16886 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16887 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16888 return 1;
16889 }
16890
16891
16892 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16893 PyObject *pyobj = 0;
16894
16895 {
16896 #if wxUSE_UNICODE
16897 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16898 #else
16899 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16900 #endif
16901 }
16902 return pyobj;
16903 }
16904
16905
16906 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16907 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16908 return 1;
16909 }
16910
16911
16912 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16913 PyObject *pyobj = 0;
16914
16915 {
16916 #if wxUSE_UNICODE
16917 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16918 #else
16919 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16920 #endif
16921 }
16922 return pyobj;
16923 }
16924
16925
16926 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16927 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16928 return 1;
16929 }
16930
16931
16932 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16933 PyObject *pyobj = 0;
16934
16935 {
16936 #if wxUSE_UNICODE
16937 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16938 #else
16939 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16940 #endif
16941 }
16942 return pyobj;
16943 }
16944
16945
16946 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16947 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16948 return 1;
16949 }
16950
16951
16952 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16953 PyObject *pyobj = 0;
16954
16955 {
16956 #if wxUSE_UNICODE
16957 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16958 #else
16959 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16960 #endif
16961 }
16962 return pyobj;
16963 }
16964
16965
16966 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16967 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16968 return 1;
16969 }
16970
16971
16972 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16973 PyObject *pyobj = 0;
16974
16975 {
16976 #if wxUSE_UNICODE
16977 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16978 #else
16979 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16980 #endif
16981 }
16982 return pyobj;
16983 }
16984
16985
16986 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16987 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16988 return 1;
16989 }
16990
16991
16992 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16993 PyObject *pyobj = 0;
16994
16995 {
16996 #if wxUSE_UNICODE
16997 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16998 #else
16999 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17000 #endif
17001 }
17002 return pyobj;
17003 }
17004
17005
17006 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17007 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17008 return 1;
17009 }
17010
17011
17012 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17013 PyObject *pyobj = 0;
17014
17015 {
17016 #if wxUSE_UNICODE
17017 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17018 #else
17019 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17020 #endif
17021 }
17022 return pyobj;
17023 }
17024
17025
17026 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17027 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17028 return 1;
17029 }
17030
17031
17032 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17033 PyObject *pyobj = 0;
17034
17035 {
17036 #if wxUSE_UNICODE
17037 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17038 #else
17039 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17040 #endif
17041 }
17042 return pyobj;
17043 }
17044
17045
17046 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17047 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17048 return 1;
17049 }
17050
17051
17052 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17053 PyObject *pyobj = 0;
17054
17055 {
17056 #if wxUSE_UNICODE
17057 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17058 #else
17059 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17060 #endif
17061 }
17062 return pyobj;
17063 }
17064
17065
17066 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17067 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17068 return 1;
17069 }
17070
17071
17072 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17073 PyObject *pyobj = 0;
17074
17075 {
17076 #if wxUSE_UNICODE
17077 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17078 #else
17079 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17080 #endif
17081 }
17082 return pyobj;
17083 }
17084
17085
17086 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17087 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17088 return 1;
17089 }
17090
17091
17092 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17093 PyObject *pyobj = 0;
17094
17095 {
17096 #if wxUSE_UNICODE
17097 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17098 #else
17099 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17100 #endif
17101 }
17102 return pyobj;
17103 }
17104
17105
17106 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17107 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17108 return 1;
17109 }
17110
17111
17112 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17113 PyObject *pyobj = 0;
17114
17115 {
17116 #if wxUSE_UNICODE
17117 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17118 #else
17119 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17120 #endif
17121 }
17122 return pyobj;
17123 }
17124
17125
17126 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17127 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17128 return 1;
17129 }
17130
17131
17132 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17133 PyObject *pyobj = 0;
17134
17135 {
17136 #if wxUSE_UNICODE
17137 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17138 #else
17139 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17140 #endif
17141 }
17142 return pyobj;
17143 }
17144
17145
17146 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17147 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17148 return 1;
17149 }
17150
17151
17152 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17153 PyObject *pyobj = 0;
17154
17155 {
17156 #if wxUSE_UNICODE
17157 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17158 #else
17159 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17160 #endif
17161 }
17162 return pyobj;
17163 }
17164
17165
17166 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17167 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17168 return 1;
17169 }
17170
17171
17172 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17173 PyObject *pyobj = 0;
17174
17175 {
17176 #if wxUSE_UNICODE
17177 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17178 #else
17179 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17180 #endif
17181 }
17182 return pyobj;
17183 }
17184
17185
17186 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17187 PyObject *resultobj = 0;
17188 wxBMPHandler *result = 0 ;
17189
17190 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17191 {
17192 PyThreadState* __tstate = wxPyBeginAllowThreads();
17193 result = (wxBMPHandler *)new wxBMPHandler();
17194 wxPyEndAllowThreads(__tstate);
17195 if (PyErr_Occurred()) SWIG_fail;
17196 }
17197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17198 return resultobj;
17199 fail:
17200 return NULL;
17201 }
17202
17203
17204 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17205 PyObject *obj;
17206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17207 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17208 return SWIG_Py_Void();
17209 }
17210
17211 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17212 return SWIG_Python_InitShadowInstance(args);
17213 }
17214
17215 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17216 PyObject *resultobj = 0;
17217 wxICOHandler *result = 0 ;
17218
17219 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17220 {
17221 PyThreadState* __tstate = wxPyBeginAllowThreads();
17222 result = (wxICOHandler *)new wxICOHandler();
17223 wxPyEndAllowThreads(__tstate);
17224 if (PyErr_Occurred()) SWIG_fail;
17225 }
17226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17227 return resultobj;
17228 fail:
17229 return NULL;
17230 }
17231
17232
17233 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17234 PyObject *obj;
17235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17236 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17237 return SWIG_Py_Void();
17238 }
17239
17240 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17241 return SWIG_Python_InitShadowInstance(args);
17242 }
17243
17244 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17245 PyObject *resultobj = 0;
17246 wxCURHandler *result = 0 ;
17247
17248 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17249 {
17250 PyThreadState* __tstate = wxPyBeginAllowThreads();
17251 result = (wxCURHandler *)new wxCURHandler();
17252 wxPyEndAllowThreads(__tstate);
17253 if (PyErr_Occurred()) SWIG_fail;
17254 }
17255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17256 return resultobj;
17257 fail:
17258 return NULL;
17259 }
17260
17261
17262 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17263 PyObject *obj;
17264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17265 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17266 return SWIG_Py_Void();
17267 }
17268
17269 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17270 return SWIG_Python_InitShadowInstance(args);
17271 }
17272
17273 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17274 PyObject *resultobj = 0;
17275 wxANIHandler *result = 0 ;
17276
17277 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17278 {
17279 PyThreadState* __tstate = wxPyBeginAllowThreads();
17280 result = (wxANIHandler *)new wxANIHandler();
17281 wxPyEndAllowThreads(__tstate);
17282 if (PyErr_Occurred()) SWIG_fail;
17283 }
17284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17285 return resultobj;
17286 fail:
17287 return NULL;
17288 }
17289
17290
17291 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17292 PyObject *obj;
17293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17294 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17295 return SWIG_Py_Void();
17296 }
17297
17298 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17299 return SWIG_Python_InitShadowInstance(args);
17300 }
17301
17302 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17303 PyObject *resultobj = 0;
17304 wxPNGHandler *result = 0 ;
17305
17306 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17307 {
17308 PyThreadState* __tstate = wxPyBeginAllowThreads();
17309 result = (wxPNGHandler *)new wxPNGHandler();
17310 wxPyEndAllowThreads(__tstate);
17311 if (PyErr_Occurred()) SWIG_fail;
17312 }
17313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17314 return resultobj;
17315 fail:
17316 return NULL;
17317 }
17318
17319
17320 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17321 PyObject *obj;
17322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17323 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17324 return SWIG_Py_Void();
17325 }
17326
17327 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17328 return SWIG_Python_InitShadowInstance(args);
17329 }
17330
17331 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17332 PyObject *resultobj = 0;
17333 wxGIFHandler *result = 0 ;
17334
17335 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17336 {
17337 PyThreadState* __tstate = wxPyBeginAllowThreads();
17338 result = (wxGIFHandler *)new wxGIFHandler();
17339 wxPyEndAllowThreads(__tstate);
17340 if (PyErr_Occurred()) SWIG_fail;
17341 }
17342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17343 return resultobj;
17344 fail:
17345 return NULL;
17346 }
17347
17348
17349 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17350 PyObject *obj;
17351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17352 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17353 return SWIG_Py_Void();
17354 }
17355
17356 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17357 return SWIG_Python_InitShadowInstance(args);
17358 }
17359
17360 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17361 PyObject *resultobj = 0;
17362 wxPCXHandler *result = 0 ;
17363
17364 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17365 {
17366 PyThreadState* __tstate = wxPyBeginAllowThreads();
17367 result = (wxPCXHandler *)new wxPCXHandler();
17368 wxPyEndAllowThreads(__tstate);
17369 if (PyErr_Occurred()) SWIG_fail;
17370 }
17371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17372 return resultobj;
17373 fail:
17374 return NULL;
17375 }
17376
17377
17378 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17379 PyObject *obj;
17380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17381 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17382 return SWIG_Py_Void();
17383 }
17384
17385 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17386 return SWIG_Python_InitShadowInstance(args);
17387 }
17388
17389 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17390 PyObject *resultobj = 0;
17391 wxJPEGHandler *result = 0 ;
17392
17393 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17394 {
17395 PyThreadState* __tstate = wxPyBeginAllowThreads();
17396 result = (wxJPEGHandler *)new wxJPEGHandler();
17397 wxPyEndAllowThreads(__tstate);
17398 if (PyErr_Occurred()) SWIG_fail;
17399 }
17400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17401 return resultobj;
17402 fail:
17403 return NULL;
17404 }
17405
17406
17407 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17408 PyObject *obj;
17409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17410 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17411 return SWIG_Py_Void();
17412 }
17413
17414 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17415 return SWIG_Python_InitShadowInstance(args);
17416 }
17417
17418 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17419 PyObject *resultobj = 0;
17420 wxPNMHandler *result = 0 ;
17421
17422 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17423 {
17424 PyThreadState* __tstate = wxPyBeginAllowThreads();
17425 result = (wxPNMHandler *)new wxPNMHandler();
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17430 return resultobj;
17431 fail:
17432 return NULL;
17433 }
17434
17435
17436 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17437 PyObject *obj;
17438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17439 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17440 return SWIG_Py_Void();
17441 }
17442
17443 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17444 return SWIG_Python_InitShadowInstance(args);
17445 }
17446
17447 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17448 PyObject *resultobj = 0;
17449 wxXPMHandler *result = 0 ;
17450
17451 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17452 {
17453 PyThreadState* __tstate = wxPyBeginAllowThreads();
17454 result = (wxXPMHandler *)new wxXPMHandler();
17455 wxPyEndAllowThreads(__tstate);
17456 if (PyErr_Occurred()) SWIG_fail;
17457 }
17458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17459 return resultobj;
17460 fail:
17461 return NULL;
17462 }
17463
17464
17465 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17466 PyObject *obj;
17467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17468 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17469 return SWIG_Py_Void();
17470 }
17471
17472 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17473 return SWIG_Python_InitShadowInstance(args);
17474 }
17475
17476 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17477 PyObject *resultobj = 0;
17478 wxTIFFHandler *result = 0 ;
17479
17480 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17481 {
17482 PyThreadState* __tstate = wxPyBeginAllowThreads();
17483 result = (wxTIFFHandler *)new wxTIFFHandler();
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17488 return resultobj;
17489 fail:
17490 return NULL;
17491 }
17492
17493
17494 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17495 PyObject *obj;
17496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17497 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17498 return SWIG_Py_Void();
17499 }
17500
17501 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17502 return SWIG_Python_InitShadowInstance(args);
17503 }
17504
17505 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17506 PyObject *resultobj = 0;
17507 wxImage *arg1 = 0 ;
17508 wxImage *arg2 = 0 ;
17509 int arg3 = (int) 236 ;
17510 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17511 bool result;
17512 void *argp1 = 0 ;
17513 int res1 = 0 ;
17514 void *argp2 = 0 ;
17515 int res2 = 0 ;
17516 int val3 ;
17517 int ecode3 = 0 ;
17518 int val4 ;
17519 int ecode4 = 0 ;
17520 PyObject * obj0 = 0 ;
17521 PyObject * obj1 = 0 ;
17522 PyObject * obj2 = 0 ;
17523 PyObject * obj3 = 0 ;
17524 char * kwnames[] = {
17525 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17526 };
17527
17528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17529 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17530 if (!SWIG_IsOK(res1)) {
17531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17532 }
17533 if (!argp1) {
17534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17535 }
17536 arg1 = reinterpret_cast< wxImage * >(argp1);
17537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17538 if (!SWIG_IsOK(res2)) {
17539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17540 }
17541 if (!argp2) {
17542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17543 }
17544 arg2 = reinterpret_cast< wxImage * >(argp2);
17545 if (obj2) {
17546 ecode3 = SWIG_AsVal_int(obj2, &val3);
17547 if (!SWIG_IsOK(ecode3)) {
17548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17549 }
17550 arg3 = static_cast< int >(val3);
17551 }
17552 if (obj3) {
17553 ecode4 = SWIG_AsVal_int(obj3, &val4);
17554 if (!SWIG_IsOK(ecode4)) {
17555 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17556 }
17557 arg4 = static_cast< int >(val4);
17558 }
17559 {
17560 PyThreadState* __tstate = wxPyBeginAllowThreads();
17561 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 {
17566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17567 }
17568 return resultobj;
17569 fail:
17570 return NULL;
17571 }
17572
17573
17574 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17575 PyObject *obj;
17576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17577 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17578 return SWIG_Py_Void();
17579 }
17580
17581 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17582 PyObject *resultobj = 0;
17583 wxEvtHandler *result = 0 ;
17584
17585 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17586 {
17587 PyThreadState* __tstate = wxPyBeginAllowThreads();
17588 result = (wxEvtHandler *)new wxEvtHandler();
17589 wxPyEndAllowThreads(__tstate);
17590 if (PyErr_Occurred()) SWIG_fail;
17591 }
17592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17600 PyObject *resultobj = 0;
17601 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17602 wxEvtHandler *result = 0 ;
17603 void *argp1 = 0 ;
17604 int res1 = 0 ;
17605 PyObject *swig_obj[1] ;
17606
17607 if (!args) SWIG_fail;
17608 swig_obj[0] = args;
17609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17610 if (!SWIG_IsOK(res1)) {
17611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17612 }
17613 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17614 {
17615 PyThreadState* __tstate = wxPyBeginAllowThreads();
17616 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17617 wxPyEndAllowThreads(__tstate);
17618 if (PyErr_Occurred()) SWIG_fail;
17619 }
17620 {
17621 resultobj = wxPyMake_wxObject(result, 0);
17622 }
17623 return resultobj;
17624 fail:
17625 return NULL;
17626 }
17627
17628
17629 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17630 PyObject *resultobj = 0;
17631 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17632 wxEvtHandler *result = 0 ;
17633 void *argp1 = 0 ;
17634 int res1 = 0 ;
17635 PyObject *swig_obj[1] ;
17636
17637 if (!args) SWIG_fail;
17638 swig_obj[0] = args;
17639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17640 if (!SWIG_IsOK(res1)) {
17641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17642 }
17643 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17644 {
17645 PyThreadState* __tstate = wxPyBeginAllowThreads();
17646 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17647 wxPyEndAllowThreads(__tstate);
17648 if (PyErr_Occurred()) SWIG_fail;
17649 }
17650 {
17651 resultobj = wxPyMake_wxObject(result, 0);
17652 }
17653 return resultobj;
17654 fail:
17655 return NULL;
17656 }
17657
17658
17659 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17660 PyObject *resultobj = 0;
17661 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17662 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17663 void *argp1 = 0 ;
17664 int res1 = 0 ;
17665 void *argp2 = 0 ;
17666 int res2 = 0 ;
17667 PyObject * obj0 = 0 ;
17668 PyObject * obj1 = 0 ;
17669 char * kwnames[] = {
17670 (char *) "self",(char *) "handler", NULL
17671 };
17672
17673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17675 if (!SWIG_IsOK(res1)) {
17676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17677 }
17678 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17680 if (!SWIG_IsOK(res2)) {
17681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17682 }
17683 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17684 {
17685 PyThreadState* __tstate = wxPyBeginAllowThreads();
17686 (arg1)->SetNextHandler(arg2);
17687 wxPyEndAllowThreads(__tstate);
17688 if (PyErr_Occurred()) SWIG_fail;
17689 }
17690 resultobj = SWIG_Py_Void();
17691 return resultobj;
17692 fail:
17693 return NULL;
17694 }
17695
17696
17697 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17698 PyObject *resultobj = 0;
17699 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17700 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17701 void *argp1 = 0 ;
17702 int res1 = 0 ;
17703 void *argp2 = 0 ;
17704 int res2 = 0 ;
17705 PyObject * obj0 = 0 ;
17706 PyObject * obj1 = 0 ;
17707 char * kwnames[] = {
17708 (char *) "self",(char *) "handler", NULL
17709 };
17710
17711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17713 if (!SWIG_IsOK(res1)) {
17714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17715 }
17716 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17717 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17718 if (!SWIG_IsOK(res2)) {
17719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17720 }
17721 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17722 {
17723 PyThreadState* __tstate = wxPyBeginAllowThreads();
17724 (arg1)->SetPreviousHandler(arg2);
17725 wxPyEndAllowThreads(__tstate);
17726 if (PyErr_Occurred()) SWIG_fail;
17727 }
17728 resultobj = SWIG_Py_Void();
17729 return resultobj;
17730 fail:
17731 return NULL;
17732 }
17733
17734
17735 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17736 PyObject *resultobj = 0;
17737 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17738 bool result;
17739 void *argp1 = 0 ;
17740 int res1 = 0 ;
17741 PyObject *swig_obj[1] ;
17742
17743 if (!args) SWIG_fail;
17744 swig_obj[0] = args;
17745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17746 if (!SWIG_IsOK(res1)) {
17747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17748 }
17749 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17750 {
17751 PyThreadState* __tstate = wxPyBeginAllowThreads();
17752 result = (bool)(arg1)->GetEvtHandlerEnabled();
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 {
17757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17758 }
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj = 0;
17767 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17768 bool arg2 ;
17769 void *argp1 = 0 ;
17770 int res1 = 0 ;
17771 bool val2 ;
17772 int ecode2 = 0 ;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 char * kwnames[] = {
17776 (char *) "self",(char *) "enabled", NULL
17777 };
17778
17779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17781 if (!SWIG_IsOK(res1)) {
17782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17783 }
17784 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17785 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17786 if (!SWIG_IsOK(ecode2)) {
17787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17788 }
17789 arg2 = static_cast< bool >(val2);
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 (arg1)->SetEvtHandlerEnabled(arg2);
17793 wxPyEndAllowThreads(__tstate);
17794 if (PyErr_Occurred()) SWIG_fail;
17795 }
17796 resultobj = SWIG_Py_Void();
17797 return resultobj;
17798 fail:
17799 return NULL;
17800 }
17801
17802
17803 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17804 PyObject *resultobj = 0;
17805 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17806 wxEvent *arg2 = 0 ;
17807 bool result;
17808 void *argp1 = 0 ;
17809 int res1 = 0 ;
17810 void *argp2 = 0 ;
17811 int res2 = 0 ;
17812 PyObject * obj0 = 0 ;
17813 PyObject * obj1 = 0 ;
17814 char * kwnames[] = {
17815 (char *) "self",(char *) "event", NULL
17816 };
17817
17818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17820 if (!SWIG_IsOK(res1)) {
17821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17822 }
17823 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17825 if (!SWIG_IsOK(res2)) {
17826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17827 }
17828 if (!argp2) {
17829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17830 }
17831 arg2 = reinterpret_cast< wxEvent * >(argp2);
17832 {
17833 PyThreadState* __tstate = wxPyBeginAllowThreads();
17834 result = (bool)(arg1)->ProcessEvent(*arg2);
17835 wxPyEndAllowThreads(__tstate);
17836 if (PyErr_Occurred()) SWIG_fail;
17837 }
17838 {
17839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17840 }
17841 return resultobj;
17842 fail:
17843 return NULL;
17844 }
17845
17846
17847 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17848 PyObject *resultobj = 0;
17849 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17850 wxEvent *arg2 = 0 ;
17851 void *argp1 = 0 ;
17852 int res1 = 0 ;
17853 void *argp2 = 0 ;
17854 int res2 = 0 ;
17855 PyObject * obj0 = 0 ;
17856 PyObject * obj1 = 0 ;
17857 char * kwnames[] = {
17858 (char *) "self",(char *) "event", NULL
17859 };
17860
17861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17863 if (!SWIG_IsOK(res1)) {
17864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17865 }
17866 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17867 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17868 if (!SWIG_IsOK(res2)) {
17869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17870 }
17871 if (!argp2) {
17872 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17873 }
17874 arg2 = reinterpret_cast< wxEvent * >(argp2);
17875 {
17876 PyThreadState* __tstate = wxPyBeginAllowThreads();
17877 (arg1)->AddPendingEvent(*arg2);
17878 wxPyEndAllowThreads(__tstate);
17879 if (PyErr_Occurred()) SWIG_fail;
17880 }
17881 resultobj = SWIG_Py_Void();
17882 return resultobj;
17883 fail:
17884 return NULL;
17885 }
17886
17887
17888 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17889 PyObject *resultobj = 0;
17890 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17891 void *argp1 = 0 ;
17892 int res1 = 0 ;
17893 PyObject *swig_obj[1] ;
17894
17895 if (!args) SWIG_fail;
17896 swig_obj[0] = args;
17897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17898 if (!SWIG_IsOK(res1)) {
17899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17900 }
17901 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17902 {
17903 PyThreadState* __tstate = wxPyBeginAllowThreads();
17904 (arg1)->ProcessPendingEvents();
17905 wxPyEndAllowThreads(__tstate);
17906 if (PyErr_Occurred()) SWIG_fail;
17907 }
17908 resultobj = SWIG_Py_Void();
17909 return resultobj;
17910 fail:
17911 return NULL;
17912 }
17913
17914
17915 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17916 PyObject *resultobj = 0;
17917 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17918 int arg2 ;
17919 int arg3 ;
17920 int arg4 ;
17921 PyObject *arg5 = (PyObject *) 0 ;
17922 void *argp1 = 0 ;
17923 int res1 = 0 ;
17924 int val2 ;
17925 int ecode2 = 0 ;
17926 int val3 ;
17927 int ecode3 = 0 ;
17928 int val4 ;
17929 int ecode4 = 0 ;
17930 PyObject * obj0 = 0 ;
17931 PyObject * obj1 = 0 ;
17932 PyObject * obj2 = 0 ;
17933 PyObject * obj3 = 0 ;
17934 PyObject * obj4 = 0 ;
17935 char * kwnames[] = {
17936 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17937 };
17938
17939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17941 if (!SWIG_IsOK(res1)) {
17942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17943 }
17944 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17945 ecode2 = SWIG_AsVal_int(obj1, &val2);
17946 if (!SWIG_IsOK(ecode2)) {
17947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17948 }
17949 arg2 = static_cast< int >(val2);
17950 ecode3 = SWIG_AsVal_int(obj2, &val3);
17951 if (!SWIG_IsOK(ecode3)) {
17952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17953 }
17954 arg3 = static_cast< int >(val3);
17955 ecode4 = SWIG_AsVal_int(obj3, &val4);
17956 if (!SWIG_IsOK(ecode4)) {
17957 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17958 }
17959 arg4 = static_cast< int >(val4);
17960 arg5 = obj4;
17961 {
17962 PyThreadState* __tstate = wxPyBeginAllowThreads();
17963 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17964 wxPyEndAllowThreads(__tstate);
17965 if (PyErr_Occurred()) SWIG_fail;
17966 }
17967 resultobj = SWIG_Py_Void();
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17975 PyObject *resultobj = 0;
17976 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17977 int arg2 ;
17978 int arg3 = (int) -1 ;
17979 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17980 bool result;
17981 void *argp1 = 0 ;
17982 int res1 = 0 ;
17983 int val2 ;
17984 int ecode2 = 0 ;
17985 int val3 ;
17986 int ecode3 = 0 ;
17987 int val4 ;
17988 int ecode4 = 0 ;
17989 PyObject * obj0 = 0 ;
17990 PyObject * obj1 = 0 ;
17991 PyObject * obj2 = 0 ;
17992 PyObject * obj3 = 0 ;
17993 char * kwnames[] = {
17994 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17995 };
17996
17997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17999 if (!SWIG_IsOK(res1)) {
18000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18001 }
18002 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18003 ecode2 = SWIG_AsVal_int(obj1, &val2);
18004 if (!SWIG_IsOK(ecode2)) {
18005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18006 }
18007 arg2 = static_cast< int >(val2);
18008 if (obj2) {
18009 ecode3 = SWIG_AsVal_int(obj2, &val3);
18010 if (!SWIG_IsOK(ecode3)) {
18011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18012 }
18013 arg3 = static_cast< int >(val3);
18014 }
18015 if (obj3) {
18016 ecode4 = SWIG_AsVal_int(obj3, &val4);
18017 if (!SWIG_IsOK(ecode4)) {
18018 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18019 }
18020 arg4 = static_cast< wxEventType >(val4);
18021 }
18022 {
18023 PyThreadState* __tstate = wxPyBeginAllowThreads();
18024 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18025 wxPyEndAllowThreads(__tstate);
18026 if (PyErr_Occurred()) SWIG_fail;
18027 }
18028 {
18029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18030 }
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18038 PyObject *resultobj = 0;
18039 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18040 PyObject *arg2 = (PyObject *) 0 ;
18041 bool arg3 = (bool) true ;
18042 void *argp1 = 0 ;
18043 int res1 = 0 ;
18044 bool val3 ;
18045 int ecode3 = 0 ;
18046 PyObject * obj0 = 0 ;
18047 PyObject * obj1 = 0 ;
18048 PyObject * obj2 = 0 ;
18049 char * kwnames[] = {
18050 (char *) "self",(char *) "_self",(char *) "incref", NULL
18051 };
18052
18053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18055 if (!SWIG_IsOK(res1)) {
18056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18057 }
18058 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18059 arg2 = obj1;
18060 if (obj2) {
18061 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18062 if (!SWIG_IsOK(ecode3)) {
18063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18064 }
18065 arg3 = static_cast< bool >(val3);
18066 }
18067 {
18068 PyThreadState* __tstate = wxPyBeginAllowThreads();
18069 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18070 wxPyEndAllowThreads(__tstate);
18071 if (PyErr_Occurred()) SWIG_fail;
18072 }
18073 resultobj = SWIG_Py_Void();
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18081 PyObject *obj;
18082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18083 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18084 return SWIG_Py_Void();
18085 }
18086
18087 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18088 return SWIG_Python_InitShadowInstance(args);
18089 }
18090
18091 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18092 PyObject *resultobj = 0;
18093 wxEventType result;
18094
18095 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18096 {
18097 PyThreadState* __tstate = wxPyBeginAllowThreads();
18098 result = (wxEventType)wxNewEventType();
18099 wxPyEndAllowThreads(__tstate);
18100 if (PyErr_Occurred()) SWIG_fail;
18101 }
18102 resultobj = SWIG_From_int(static_cast< int >(result));
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18110 PyObject *resultobj = 0;
18111 wxEvent *arg1 = (wxEvent *) 0 ;
18112 void *argp1 = 0 ;
18113 int res1 = 0 ;
18114 PyObject *swig_obj[1] ;
18115
18116 if (!args) SWIG_fail;
18117 swig_obj[0] = args;
18118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18119 if (!SWIG_IsOK(res1)) {
18120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18121 }
18122 arg1 = reinterpret_cast< wxEvent * >(argp1);
18123 {
18124 PyThreadState* __tstate = wxPyBeginAllowThreads();
18125 delete arg1;
18126
18127 wxPyEndAllowThreads(__tstate);
18128 if (PyErr_Occurred()) SWIG_fail;
18129 }
18130 resultobj = SWIG_Py_Void();
18131 return resultobj;
18132 fail:
18133 return NULL;
18134 }
18135
18136
18137 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18138 PyObject *resultobj = 0;
18139 wxEvent *arg1 = (wxEvent *) 0 ;
18140 wxEventType arg2 ;
18141 void *argp1 = 0 ;
18142 int res1 = 0 ;
18143 int val2 ;
18144 int ecode2 = 0 ;
18145 PyObject * obj0 = 0 ;
18146 PyObject * obj1 = 0 ;
18147 char * kwnames[] = {
18148 (char *) "self",(char *) "typ", NULL
18149 };
18150
18151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18153 if (!SWIG_IsOK(res1)) {
18154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18155 }
18156 arg1 = reinterpret_cast< wxEvent * >(argp1);
18157 ecode2 = SWIG_AsVal_int(obj1, &val2);
18158 if (!SWIG_IsOK(ecode2)) {
18159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18160 }
18161 arg2 = static_cast< wxEventType >(val2);
18162 {
18163 PyThreadState* __tstate = wxPyBeginAllowThreads();
18164 (arg1)->SetEventType(arg2);
18165 wxPyEndAllowThreads(__tstate);
18166 if (PyErr_Occurred()) SWIG_fail;
18167 }
18168 resultobj = SWIG_Py_Void();
18169 return resultobj;
18170 fail:
18171 return NULL;
18172 }
18173
18174
18175 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18176 PyObject *resultobj = 0;
18177 wxEvent *arg1 = (wxEvent *) 0 ;
18178 wxEventType result;
18179 void *argp1 = 0 ;
18180 int res1 = 0 ;
18181 PyObject *swig_obj[1] ;
18182
18183 if (!args) SWIG_fail;
18184 swig_obj[0] = args;
18185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18186 if (!SWIG_IsOK(res1)) {
18187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18188 }
18189 arg1 = reinterpret_cast< wxEvent * >(argp1);
18190 {
18191 PyThreadState* __tstate = wxPyBeginAllowThreads();
18192 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18193 wxPyEndAllowThreads(__tstate);
18194 if (PyErr_Occurred()) SWIG_fail;
18195 }
18196 resultobj = SWIG_From_int(static_cast< int >(result));
18197 return resultobj;
18198 fail:
18199 return NULL;
18200 }
18201
18202
18203 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18204 PyObject *resultobj = 0;
18205 wxEvent *arg1 = (wxEvent *) 0 ;
18206 wxObject *result = 0 ;
18207 void *argp1 = 0 ;
18208 int res1 = 0 ;
18209 PyObject *swig_obj[1] ;
18210
18211 if (!args) SWIG_fail;
18212 swig_obj[0] = args;
18213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18214 if (!SWIG_IsOK(res1)) {
18215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18216 }
18217 arg1 = reinterpret_cast< wxEvent * >(argp1);
18218 {
18219 PyThreadState* __tstate = wxPyBeginAllowThreads();
18220 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18221 wxPyEndAllowThreads(__tstate);
18222 if (PyErr_Occurred()) SWIG_fail;
18223 }
18224 {
18225 resultobj = wxPyMake_wxObject(result, (bool)0);
18226 }
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18234 PyObject *resultobj = 0;
18235 wxEvent *arg1 = (wxEvent *) 0 ;
18236 wxObject *arg2 = (wxObject *) 0 ;
18237 void *argp1 = 0 ;
18238 int res1 = 0 ;
18239 void *argp2 = 0 ;
18240 int res2 = 0 ;
18241 PyObject * obj0 = 0 ;
18242 PyObject * obj1 = 0 ;
18243 char * kwnames[] = {
18244 (char *) "self",(char *) "obj", NULL
18245 };
18246
18247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18249 if (!SWIG_IsOK(res1)) {
18250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18251 }
18252 arg1 = reinterpret_cast< wxEvent * >(argp1);
18253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18254 if (!SWIG_IsOK(res2)) {
18255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18256 }
18257 arg2 = reinterpret_cast< wxObject * >(argp2);
18258 {
18259 PyThreadState* __tstate = wxPyBeginAllowThreads();
18260 (arg1)->SetEventObject(arg2);
18261 wxPyEndAllowThreads(__tstate);
18262 if (PyErr_Occurred()) SWIG_fail;
18263 }
18264 resultobj = SWIG_Py_Void();
18265 return resultobj;
18266 fail:
18267 return NULL;
18268 }
18269
18270
18271 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18272 PyObject *resultobj = 0;
18273 wxEvent *arg1 = (wxEvent *) 0 ;
18274 long result;
18275 void *argp1 = 0 ;
18276 int res1 = 0 ;
18277 PyObject *swig_obj[1] ;
18278
18279 if (!args) SWIG_fail;
18280 swig_obj[0] = args;
18281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18282 if (!SWIG_IsOK(res1)) {
18283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18284 }
18285 arg1 = reinterpret_cast< wxEvent * >(argp1);
18286 {
18287 PyThreadState* __tstate = wxPyBeginAllowThreads();
18288 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18289 wxPyEndAllowThreads(__tstate);
18290 if (PyErr_Occurred()) SWIG_fail;
18291 }
18292 resultobj = SWIG_From_long(static_cast< long >(result));
18293 return resultobj;
18294 fail:
18295 return NULL;
18296 }
18297
18298
18299 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18300 PyObject *resultobj = 0;
18301 wxEvent *arg1 = (wxEvent *) 0 ;
18302 long arg2 = (long) 0 ;
18303 void *argp1 = 0 ;
18304 int res1 = 0 ;
18305 long val2 ;
18306 int ecode2 = 0 ;
18307 PyObject * obj0 = 0 ;
18308 PyObject * obj1 = 0 ;
18309 char * kwnames[] = {
18310 (char *) "self",(char *) "ts", NULL
18311 };
18312
18313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18315 if (!SWIG_IsOK(res1)) {
18316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18317 }
18318 arg1 = reinterpret_cast< wxEvent * >(argp1);
18319 if (obj1) {
18320 ecode2 = SWIG_AsVal_long(obj1, &val2);
18321 if (!SWIG_IsOK(ecode2)) {
18322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18323 }
18324 arg2 = static_cast< long >(val2);
18325 }
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 (arg1)->SetTimestamp(arg2);
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 resultobj = SWIG_Py_Void();
18333 return resultobj;
18334 fail:
18335 return NULL;
18336 }
18337
18338
18339 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18340 PyObject *resultobj = 0;
18341 wxEvent *arg1 = (wxEvent *) 0 ;
18342 int result;
18343 void *argp1 = 0 ;
18344 int res1 = 0 ;
18345 PyObject *swig_obj[1] ;
18346
18347 if (!args) SWIG_fail;
18348 swig_obj[0] = args;
18349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18350 if (!SWIG_IsOK(res1)) {
18351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18352 }
18353 arg1 = reinterpret_cast< wxEvent * >(argp1);
18354 {
18355 PyThreadState* __tstate = wxPyBeginAllowThreads();
18356 result = (int)((wxEvent const *)arg1)->GetId();
18357 wxPyEndAllowThreads(__tstate);
18358 if (PyErr_Occurred()) SWIG_fail;
18359 }
18360 resultobj = SWIG_From_int(static_cast< int >(result));
18361 return resultobj;
18362 fail:
18363 return NULL;
18364 }
18365
18366
18367 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18368 PyObject *resultobj = 0;
18369 wxEvent *arg1 = (wxEvent *) 0 ;
18370 int arg2 ;
18371 void *argp1 = 0 ;
18372 int res1 = 0 ;
18373 int val2 ;
18374 int ecode2 = 0 ;
18375 PyObject * obj0 = 0 ;
18376 PyObject * obj1 = 0 ;
18377 char * kwnames[] = {
18378 (char *) "self",(char *) "Id", NULL
18379 };
18380
18381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18383 if (!SWIG_IsOK(res1)) {
18384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18385 }
18386 arg1 = reinterpret_cast< wxEvent * >(argp1);
18387 ecode2 = SWIG_AsVal_int(obj1, &val2);
18388 if (!SWIG_IsOK(ecode2)) {
18389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18390 }
18391 arg2 = static_cast< int >(val2);
18392 {
18393 PyThreadState* __tstate = wxPyBeginAllowThreads();
18394 (arg1)->SetId(arg2);
18395 wxPyEndAllowThreads(__tstate);
18396 if (PyErr_Occurred()) SWIG_fail;
18397 }
18398 resultobj = SWIG_Py_Void();
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18406 PyObject *resultobj = 0;
18407 wxEvent *arg1 = (wxEvent *) 0 ;
18408 bool result;
18409 void *argp1 = 0 ;
18410 int res1 = 0 ;
18411 PyObject *swig_obj[1] ;
18412
18413 if (!args) SWIG_fail;
18414 swig_obj[0] = args;
18415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18416 if (!SWIG_IsOK(res1)) {
18417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18418 }
18419 arg1 = reinterpret_cast< wxEvent * >(argp1);
18420 {
18421 PyThreadState* __tstate = wxPyBeginAllowThreads();
18422 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18423 wxPyEndAllowThreads(__tstate);
18424 if (PyErr_Occurred()) SWIG_fail;
18425 }
18426 {
18427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18428 }
18429 return resultobj;
18430 fail:
18431 return NULL;
18432 }
18433
18434
18435 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18436 PyObject *resultobj = 0;
18437 wxEvent *arg1 = (wxEvent *) 0 ;
18438 bool arg2 = (bool) true ;
18439 void *argp1 = 0 ;
18440 int res1 = 0 ;
18441 bool val2 ;
18442 int ecode2 = 0 ;
18443 PyObject * obj0 = 0 ;
18444 PyObject * obj1 = 0 ;
18445 char * kwnames[] = {
18446 (char *) "self",(char *) "skip", NULL
18447 };
18448
18449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18451 if (!SWIG_IsOK(res1)) {
18452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18453 }
18454 arg1 = reinterpret_cast< wxEvent * >(argp1);
18455 if (obj1) {
18456 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18457 if (!SWIG_IsOK(ecode2)) {
18458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18459 }
18460 arg2 = static_cast< bool >(val2);
18461 }
18462 {
18463 PyThreadState* __tstate = wxPyBeginAllowThreads();
18464 (arg1)->Skip(arg2);
18465 wxPyEndAllowThreads(__tstate);
18466 if (PyErr_Occurred()) SWIG_fail;
18467 }
18468 resultobj = SWIG_Py_Void();
18469 return resultobj;
18470 fail:
18471 return NULL;
18472 }
18473
18474
18475 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18476 PyObject *resultobj = 0;
18477 wxEvent *arg1 = (wxEvent *) 0 ;
18478 bool result;
18479 void *argp1 = 0 ;
18480 int res1 = 0 ;
18481 PyObject *swig_obj[1] ;
18482
18483 if (!args) SWIG_fail;
18484 swig_obj[0] = args;
18485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18486 if (!SWIG_IsOK(res1)) {
18487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18488 }
18489 arg1 = reinterpret_cast< wxEvent * >(argp1);
18490 {
18491 PyThreadState* __tstate = wxPyBeginAllowThreads();
18492 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18493 wxPyEndAllowThreads(__tstate);
18494 if (PyErr_Occurred()) SWIG_fail;
18495 }
18496 {
18497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18498 }
18499 return resultobj;
18500 fail:
18501 return NULL;
18502 }
18503
18504
18505 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18506 PyObject *resultobj = 0;
18507 wxEvent *arg1 = (wxEvent *) 0 ;
18508 bool result;
18509 void *argp1 = 0 ;
18510 int res1 = 0 ;
18511 PyObject *swig_obj[1] ;
18512
18513 if (!args) SWIG_fail;
18514 swig_obj[0] = args;
18515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18516 if (!SWIG_IsOK(res1)) {
18517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18518 }
18519 arg1 = reinterpret_cast< wxEvent * >(argp1);
18520 {
18521 PyThreadState* __tstate = wxPyBeginAllowThreads();
18522 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18523 wxPyEndAllowThreads(__tstate);
18524 if (PyErr_Occurred()) SWIG_fail;
18525 }
18526 {
18527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18528 }
18529 return resultobj;
18530 fail:
18531 return NULL;
18532 }
18533
18534
18535 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18536 PyObject *resultobj = 0;
18537 wxEvent *arg1 = (wxEvent *) 0 ;
18538 int result;
18539 void *argp1 = 0 ;
18540 int res1 = 0 ;
18541 PyObject *swig_obj[1] ;
18542
18543 if (!args) SWIG_fail;
18544 swig_obj[0] = args;
18545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18546 if (!SWIG_IsOK(res1)) {
18547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18548 }
18549 arg1 = reinterpret_cast< wxEvent * >(argp1);
18550 {
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 result = (int)(arg1)->StopPropagation();
18553 wxPyEndAllowThreads(__tstate);
18554 if (PyErr_Occurred()) SWIG_fail;
18555 }
18556 resultobj = SWIG_From_int(static_cast< int >(result));
18557 return resultobj;
18558 fail:
18559 return NULL;
18560 }
18561
18562
18563 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18564 PyObject *resultobj = 0;
18565 wxEvent *arg1 = (wxEvent *) 0 ;
18566 int arg2 ;
18567 void *argp1 = 0 ;
18568 int res1 = 0 ;
18569 int val2 ;
18570 int ecode2 = 0 ;
18571 PyObject * obj0 = 0 ;
18572 PyObject * obj1 = 0 ;
18573 char * kwnames[] = {
18574 (char *) "self",(char *) "propagationLevel", NULL
18575 };
18576
18577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18579 if (!SWIG_IsOK(res1)) {
18580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18581 }
18582 arg1 = reinterpret_cast< wxEvent * >(argp1);
18583 ecode2 = SWIG_AsVal_int(obj1, &val2);
18584 if (!SWIG_IsOK(ecode2)) {
18585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18586 }
18587 arg2 = static_cast< int >(val2);
18588 {
18589 PyThreadState* __tstate = wxPyBeginAllowThreads();
18590 (arg1)->ResumePropagation(arg2);
18591 wxPyEndAllowThreads(__tstate);
18592 if (PyErr_Occurred()) SWIG_fail;
18593 }
18594 resultobj = SWIG_Py_Void();
18595 return resultobj;
18596 fail:
18597 return NULL;
18598 }
18599
18600
18601 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18602 PyObject *resultobj = 0;
18603 wxEvent *arg1 = (wxEvent *) 0 ;
18604 wxEvent *result = 0 ;
18605 void *argp1 = 0 ;
18606 int res1 = 0 ;
18607 PyObject *swig_obj[1] ;
18608
18609 if (!args) SWIG_fail;
18610 swig_obj[0] = args;
18611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18612 if (!SWIG_IsOK(res1)) {
18613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18614 }
18615 arg1 = reinterpret_cast< wxEvent * >(argp1);
18616 {
18617 PyThreadState* __tstate = wxPyBeginAllowThreads();
18618 result = (wxEvent *)(arg1)->Clone();
18619 wxPyEndAllowThreads(__tstate);
18620 if (PyErr_Occurred()) SWIG_fail;
18621 }
18622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18623 return resultobj;
18624 fail:
18625 return NULL;
18626 }
18627
18628
18629 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18630 PyObject *obj;
18631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18632 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18633 return SWIG_Py_Void();
18634 }
18635
18636 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18637 PyObject *resultobj = 0;
18638 wxEvent *arg1 = 0 ;
18639 wxPropagationDisabler *result = 0 ;
18640 void *argp1 = 0 ;
18641 int res1 = 0 ;
18642 PyObject * obj0 = 0 ;
18643 char * kwnames[] = {
18644 (char *) "event", NULL
18645 };
18646
18647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18648 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18649 if (!SWIG_IsOK(res1)) {
18650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18651 }
18652 if (!argp1) {
18653 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18654 }
18655 arg1 = reinterpret_cast< wxEvent * >(argp1);
18656 {
18657 PyThreadState* __tstate = wxPyBeginAllowThreads();
18658 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18663 return resultobj;
18664 fail:
18665 return NULL;
18666 }
18667
18668
18669 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18670 PyObject *resultobj = 0;
18671 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18672 void *argp1 = 0 ;
18673 int res1 = 0 ;
18674 PyObject *swig_obj[1] ;
18675
18676 if (!args) SWIG_fail;
18677 swig_obj[0] = args;
18678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18679 if (!SWIG_IsOK(res1)) {
18680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18681 }
18682 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18683 {
18684 PyThreadState* __tstate = wxPyBeginAllowThreads();
18685 delete arg1;
18686
18687 wxPyEndAllowThreads(__tstate);
18688 if (PyErr_Occurred()) SWIG_fail;
18689 }
18690 resultobj = SWIG_Py_Void();
18691 return resultobj;
18692 fail:
18693 return NULL;
18694 }
18695
18696
18697 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18698 PyObject *obj;
18699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18700 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18701 return SWIG_Py_Void();
18702 }
18703
18704 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18705 return SWIG_Python_InitShadowInstance(args);
18706 }
18707
18708 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18709 PyObject *resultobj = 0;
18710 wxEvent *arg1 = 0 ;
18711 wxPropagateOnce *result = 0 ;
18712 void *argp1 = 0 ;
18713 int res1 = 0 ;
18714 PyObject * obj0 = 0 ;
18715 char * kwnames[] = {
18716 (char *) "event", NULL
18717 };
18718
18719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18720 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18721 if (!SWIG_IsOK(res1)) {
18722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18723 }
18724 if (!argp1) {
18725 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18726 }
18727 arg1 = reinterpret_cast< wxEvent * >(argp1);
18728 {
18729 PyThreadState* __tstate = wxPyBeginAllowThreads();
18730 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18731 wxPyEndAllowThreads(__tstate);
18732 if (PyErr_Occurred()) SWIG_fail;
18733 }
18734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18735 return resultobj;
18736 fail:
18737 return NULL;
18738 }
18739
18740
18741 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18742 PyObject *resultobj = 0;
18743 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18744 void *argp1 = 0 ;
18745 int res1 = 0 ;
18746 PyObject *swig_obj[1] ;
18747
18748 if (!args) SWIG_fail;
18749 swig_obj[0] = args;
18750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18751 if (!SWIG_IsOK(res1)) {
18752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18753 }
18754 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18755 {
18756 PyThreadState* __tstate = wxPyBeginAllowThreads();
18757 delete arg1;
18758
18759 wxPyEndAllowThreads(__tstate);
18760 if (PyErr_Occurred()) SWIG_fail;
18761 }
18762 resultobj = SWIG_Py_Void();
18763 return resultobj;
18764 fail:
18765 return NULL;
18766 }
18767
18768
18769 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18770 PyObject *obj;
18771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18772 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18773 return SWIG_Py_Void();
18774 }
18775
18776 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18777 return SWIG_Python_InitShadowInstance(args);
18778 }
18779
18780 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18781 PyObject *resultobj = 0;
18782 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18783 int arg2 = (int) 0 ;
18784 wxCommandEvent *result = 0 ;
18785 int val1 ;
18786 int ecode1 = 0 ;
18787 int val2 ;
18788 int ecode2 = 0 ;
18789 PyObject * obj0 = 0 ;
18790 PyObject * obj1 = 0 ;
18791 char * kwnames[] = {
18792 (char *) "commandType",(char *) "winid", NULL
18793 };
18794
18795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18796 if (obj0) {
18797 ecode1 = SWIG_AsVal_int(obj0, &val1);
18798 if (!SWIG_IsOK(ecode1)) {
18799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18800 }
18801 arg1 = static_cast< wxEventType >(val1);
18802 }
18803 if (obj1) {
18804 ecode2 = SWIG_AsVal_int(obj1, &val2);
18805 if (!SWIG_IsOK(ecode2)) {
18806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18807 }
18808 arg2 = static_cast< int >(val2);
18809 }
18810 {
18811 PyThreadState* __tstate = wxPyBeginAllowThreads();
18812 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18813 wxPyEndAllowThreads(__tstate);
18814 if (PyErr_Occurred()) SWIG_fail;
18815 }
18816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18824 PyObject *resultobj = 0;
18825 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18826 int result;
18827 void *argp1 = 0 ;
18828 int res1 = 0 ;
18829 PyObject *swig_obj[1] ;
18830
18831 if (!args) SWIG_fail;
18832 swig_obj[0] = args;
18833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18834 if (!SWIG_IsOK(res1)) {
18835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18836 }
18837 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18838 {
18839 PyThreadState* __tstate = wxPyBeginAllowThreads();
18840 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18841 wxPyEndAllowThreads(__tstate);
18842 if (PyErr_Occurred()) SWIG_fail;
18843 }
18844 resultobj = SWIG_From_int(static_cast< int >(result));
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj = 0;
18853 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18854 wxString *arg2 = 0 ;
18855 void *argp1 = 0 ;
18856 int res1 = 0 ;
18857 bool temp2 = false ;
18858 PyObject * obj0 = 0 ;
18859 PyObject * obj1 = 0 ;
18860 char * kwnames[] = {
18861 (char *) "self",(char *) "s", NULL
18862 };
18863
18864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18866 if (!SWIG_IsOK(res1)) {
18867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18868 }
18869 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18870 {
18871 arg2 = wxString_in_helper(obj1);
18872 if (arg2 == NULL) SWIG_fail;
18873 temp2 = true;
18874 }
18875 {
18876 PyThreadState* __tstate = wxPyBeginAllowThreads();
18877 (arg1)->SetString((wxString const &)*arg2);
18878 wxPyEndAllowThreads(__tstate);
18879 if (PyErr_Occurred()) SWIG_fail;
18880 }
18881 resultobj = SWIG_Py_Void();
18882 {
18883 if (temp2)
18884 delete arg2;
18885 }
18886 return resultobj;
18887 fail:
18888 {
18889 if (temp2)
18890 delete arg2;
18891 }
18892 return NULL;
18893 }
18894
18895
18896 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18897 PyObject *resultobj = 0;
18898 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18899 wxString result;
18900 void *argp1 = 0 ;
18901 int res1 = 0 ;
18902 PyObject *swig_obj[1] ;
18903
18904 if (!args) SWIG_fail;
18905 swig_obj[0] = args;
18906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18907 if (!SWIG_IsOK(res1)) {
18908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18909 }
18910 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18911 {
18912 PyThreadState* __tstate = wxPyBeginAllowThreads();
18913 result = ((wxCommandEvent const *)arg1)->GetString();
18914 wxPyEndAllowThreads(__tstate);
18915 if (PyErr_Occurred()) SWIG_fail;
18916 }
18917 {
18918 #if wxUSE_UNICODE
18919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18920 #else
18921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18922 #endif
18923 }
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18931 PyObject *resultobj = 0;
18932 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18933 bool result;
18934 void *argp1 = 0 ;
18935 int res1 = 0 ;
18936 PyObject *swig_obj[1] ;
18937
18938 if (!args) SWIG_fail;
18939 swig_obj[0] = args;
18940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18941 if (!SWIG_IsOK(res1)) {
18942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18943 }
18944 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18945 {
18946 PyThreadState* __tstate = wxPyBeginAllowThreads();
18947 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18948 wxPyEndAllowThreads(__tstate);
18949 if (PyErr_Occurred()) SWIG_fail;
18950 }
18951 {
18952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18953 }
18954 return resultobj;
18955 fail:
18956 return NULL;
18957 }
18958
18959
18960 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18961 PyObject *resultobj = 0;
18962 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18963 bool result;
18964 void *argp1 = 0 ;
18965 int res1 = 0 ;
18966 PyObject *swig_obj[1] ;
18967
18968 if (!args) SWIG_fail;
18969 swig_obj[0] = args;
18970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18971 if (!SWIG_IsOK(res1)) {
18972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18973 }
18974 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18975 {
18976 PyThreadState* __tstate = wxPyBeginAllowThreads();
18977 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18978 wxPyEndAllowThreads(__tstate);
18979 if (PyErr_Occurred()) SWIG_fail;
18980 }
18981 {
18982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18983 }
18984 return resultobj;
18985 fail:
18986 return NULL;
18987 }
18988
18989
18990 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18991 PyObject *resultobj = 0;
18992 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18993 long arg2 ;
18994 void *argp1 = 0 ;
18995 int res1 = 0 ;
18996 long val2 ;
18997 int ecode2 = 0 ;
18998 PyObject * obj0 = 0 ;
18999 PyObject * obj1 = 0 ;
19000 char * kwnames[] = {
19001 (char *) "self",(char *) "extraLong", NULL
19002 };
19003
19004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19006 if (!SWIG_IsOK(res1)) {
19007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19008 }
19009 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19010 ecode2 = SWIG_AsVal_long(obj1, &val2);
19011 if (!SWIG_IsOK(ecode2)) {
19012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19013 }
19014 arg2 = static_cast< long >(val2);
19015 {
19016 PyThreadState* __tstate = wxPyBeginAllowThreads();
19017 (arg1)->SetExtraLong(arg2);
19018 wxPyEndAllowThreads(__tstate);
19019 if (PyErr_Occurred()) SWIG_fail;
19020 }
19021 resultobj = SWIG_Py_Void();
19022 return resultobj;
19023 fail:
19024 return NULL;
19025 }
19026
19027
19028 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19029 PyObject *resultobj = 0;
19030 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19031 long result;
19032 void *argp1 = 0 ;
19033 int res1 = 0 ;
19034 PyObject *swig_obj[1] ;
19035
19036 if (!args) SWIG_fail;
19037 swig_obj[0] = args;
19038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19039 if (!SWIG_IsOK(res1)) {
19040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19041 }
19042 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19043 {
19044 PyThreadState* __tstate = wxPyBeginAllowThreads();
19045 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19046 wxPyEndAllowThreads(__tstate);
19047 if (PyErr_Occurred()) SWIG_fail;
19048 }
19049 resultobj = SWIG_From_long(static_cast< long >(result));
19050 return resultobj;
19051 fail:
19052 return NULL;
19053 }
19054
19055
19056 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19057 PyObject *resultobj = 0;
19058 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19059 int arg2 ;
19060 void *argp1 = 0 ;
19061 int res1 = 0 ;
19062 int val2 ;
19063 int ecode2 = 0 ;
19064 PyObject * obj0 = 0 ;
19065 PyObject * obj1 = 0 ;
19066 char * kwnames[] = {
19067 (char *) "self",(char *) "i", NULL
19068 };
19069
19070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19072 if (!SWIG_IsOK(res1)) {
19073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19074 }
19075 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19076 ecode2 = SWIG_AsVal_int(obj1, &val2);
19077 if (!SWIG_IsOK(ecode2)) {
19078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19079 }
19080 arg2 = static_cast< int >(val2);
19081 {
19082 PyThreadState* __tstate = wxPyBeginAllowThreads();
19083 (arg1)->SetInt(arg2);
19084 wxPyEndAllowThreads(__tstate);
19085 if (PyErr_Occurred()) SWIG_fail;
19086 }
19087 resultobj = SWIG_Py_Void();
19088 return resultobj;
19089 fail:
19090 return NULL;
19091 }
19092
19093
19094 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19095 PyObject *resultobj = 0;
19096 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19097 int result;
19098 void *argp1 = 0 ;
19099 int res1 = 0 ;
19100 PyObject *swig_obj[1] ;
19101
19102 if (!args) SWIG_fail;
19103 swig_obj[0] = args;
19104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19105 if (!SWIG_IsOK(res1)) {
19106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19107 }
19108 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19109 {
19110 PyThreadState* __tstate = wxPyBeginAllowThreads();
19111 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19112 wxPyEndAllowThreads(__tstate);
19113 if (PyErr_Occurred()) SWIG_fail;
19114 }
19115 resultobj = SWIG_From_int(static_cast< int >(result));
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19123 PyObject *resultobj = 0;
19124 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19125 PyObject *result = 0 ;
19126 void *argp1 = 0 ;
19127 int res1 = 0 ;
19128 PyObject *swig_obj[1] ;
19129
19130 if (!args) SWIG_fail;
19131 swig_obj[0] = args;
19132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19133 if (!SWIG_IsOK(res1)) {
19134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19135 }
19136 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19137 {
19138 PyThreadState* __tstate = wxPyBeginAllowThreads();
19139 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19140 wxPyEndAllowThreads(__tstate);
19141 if (PyErr_Occurred()) SWIG_fail;
19142 }
19143 resultobj = result;
19144 return resultobj;
19145 fail:
19146 return NULL;
19147 }
19148
19149
19150 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19151 PyObject *resultobj = 0;
19152 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19153 PyObject *arg2 = (PyObject *) 0 ;
19154 void *argp1 = 0 ;
19155 int res1 = 0 ;
19156 PyObject * obj0 = 0 ;
19157 PyObject * obj1 = 0 ;
19158 char * kwnames[] = {
19159 (char *) "self",(char *) "clientData", NULL
19160 };
19161
19162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19164 if (!SWIG_IsOK(res1)) {
19165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19166 }
19167 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19168 arg2 = obj1;
19169 {
19170 PyThreadState* __tstate = wxPyBeginAllowThreads();
19171 wxCommandEvent_SetClientData(arg1,arg2);
19172 wxPyEndAllowThreads(__tstate);
19173 if (PyErr_Occurred()) SWIG_fail;
19174 }
19175 resultobj = SWIG_Py_Void();
19176 return resultobj;
19177 fail:
19178 return NULL;
19179 }
19180
19181
19182 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19183 PyObject *resultobj = 0;
19184 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19185 wxEvent *result = 0 ;
19186 void *argp1 = 0 ;
19187 int res1 = 0 ;
19188 PyObject *swig_obj[1] ;
19189
19190 if (!args) SWIG_fail;
19191 swig_obj[0] = args;
19192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19193 if (!SWIG_IsOK(res1)) {
19194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19195 }
19196 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19197 {
19198 PyThreadState* __tstate = wxPyBeginAllowThreads();
19199 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19200 wxPyEndAllowThreads(__tstate);
19201 if (PyErr_Occurred()) SWIG_fail;
19202 }
19203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19204 return resultobj;
19205 fail:
19206 return NULL;
19207 }
19208
19209
19210 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19211 PyObject *obj;
19212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19213 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19214 return SWIG_Py_Void();
19215 }
19216
19217 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19218 return SWIG_Python_InitShadowInstance(args);
19219 }
19220
19221 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19222 PyObject *resultobj = 0;
19223 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19224 int arg2 = (int) 0 ;
19225 wxNotifyEvent *result = 0 ;
19226 int val1 ;
19227 int ecode1 = 0 ;
19228 int val2 ;
19229 int ecode2 = 0 ;
19230 PyObject * obj0 = 0 ;
19231 PyObject * obj1 = 0 ;
19232 char * kwnames[] = {
19233 (char *) "commandType",(char *) "winid", NULL
19234 };
19235
19236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19237 if (obj0) {
19238 ecode1 = SWIG_AsVal_int(obj0, &val1);
19239 if (!SWIG_IsOK(ecode1)) {
19240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19241 }
19242 arg1 = static_cast< wxEventType >(val1);
19243 }
19244 if (obj1) {
19245 ecode2 = SWIG_AsVal_int(obj1, &val2);
19246 if (!SWIG_IsOK(ecode2)) {
19247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19248 }
19249 arg2 = static_cast< int >(val2);
19250 }
19251 {
19252 PyThreadState* __tstate = wxPyBeginAllowThreads();
19253 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19265 PyObject *resultobj = 0;
19266 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19267 void *argp1 = 0 ;
19268 int res1 = 0 ;
19269 PyObject *swig_obj[1] ;
19270
19271 if (!args) SWIG_fail;
19272 swig_obj[0] = args;
19273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19274 if (!SWIG_IsOK(res1)) {
19275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19276 }
19277 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19278 {
19279 PyThreadState* __tstate = wxPyBeginAllowThreads();
19280 (arg1)->Veto();
19281 wxPyEndAllowThreads(__tstate);
19282 if (PyErr_Occurred()) SWIG_fail;
19283 }
19284 resultobj = SWIG_Py_Void();
19285 return resultobj;
19286 fail:
19287 return NULL;
19288 }
19289
19290
19291 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19292 PyObject *resultobj = 0;
19293 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19294 void *argp1 = 0 ;
19295 int res1 = 0 ;
19296 PyObject *swig_obj[1] ;
19297
19298 if (!args) SWIG_fail;
19299 swig_obj[0] = args;
19300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19301 if (!SWIG_IsOK(res1)) {
19302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19303 }
19304 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19305 {
19306 PyThreadState* __tstate = wxPyBeginAllowThreads();
19307 (arg1)->Allow();
19308 wxPyEndAllowThreads(__tstate);
19309 if (PyErr_Occurred()) SWIG_fail;
19310 }
19311 resultobj = SWIG_Py_Void();
19312 return resultobj;
19313 fail:
19314 return NULL;
19315 }
19316
19317
19318 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19319 PyObject *resultobj = 0;
19320 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19321 bool result;
19322 void *argp1 = 0 ;
19323 int res1 = 0 ;
19324 PyObject *swig_obj[1] ;
19325
19326 if (!args) SWIG_fail;
19327 swig_obj[0] = args;
19328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19329 if (!SWIG_IsOK(res1)) {
19330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19331 }
19332 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19333 {
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 result = (bool)(arg1)->IsAllowed();
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 {
19340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19341 }
19342 return resultobj;
19343 fail:
19344 return NULL;
19345 }
19346
19347
19348 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19349 PyObject *obj;
19350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19351 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19352 return SWIG_Py_Void();
19353 }
19354
19355 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19356 return SWIG_Python_InitShadowInstance(args);
19357 }
19358
19359 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19360 PyObject *resultobj = 0;
19361 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19362 int arg2 = (int) 0 ;
19363 int arg3 = (int) 0 ;
19364 int arg4 = (int) 0 ;
19365 wxScrollEvent *result = 0 ;
19366 int val1 ;
19367 int ecode1 = 0 ;
19368 int val2 ;
19369 int ecode2 = 0 ;
19370 int val3 ;
19371 int ecode3 = 0 ;
19372 int val4 ;
19373 int ecode4 = 0 ;
19374 PyObject * obj0 = 0 ;
19375 PyObject * obj1 = 0 ;
19376 PyObject * obj2 = 0 ;
19377 PyObject * obj3 = 0 ;
19378 char * kwnames[] = {
19379 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19380 };
19381
19382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19383 if (obj0) {
19384 ecode1 = SWIG_AsVal_int(obj0, &val1);
19385 if (!SWIG_IsOK(ecode1)) {
19386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19387 }
19388 arg1 = static_cast< wxEventType >(val1);
19389 }
19390 if (obj1) {
19391 ecode2 = SWIG_AsVal_int(obj1, &val2);
19392 if (!SWIG_IsOK(ecode2)) {
19393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19394 }
19395 arg2 = static_cast< int >(val2);
19396 }
19397 if (obj2) {
19398 ecode3 = SWIG_AsVal_int(obj2, &val3);
19399 if (!SWIG_IsOK(ecode3)) {
19400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19401 }
19402 arg3 = static_cast< int >(val3);
19403 }
19404 if (obj3) {
19405 ecode4 = SWIG_AsVal_int(obj3, &val4);
19406 if (!SWIG_IsOK(ecode4)) {
19407 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19408 }
19409 arg4 = static_cast< int >(val4);
19410 }
19411 {
19412 PyThreadState* __tstate = wxPyBeginAllowThreads();
19413 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19414 wxPyEndAllowThreads(__tstate);
19415 if (PyErr_Occurred()) SWIG_fail;
19416 }
19417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19425 PyObject *resultobj = 0;
19426 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19427 int result;
19428 void *argp1 = 0 ;
19429 int res1 = 0 ;
19430 PyObject *swig_obj[1] ;
19431
19432 if (!args) SWIG_fail;
19433 swig_obj[0] = args;
19434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19435 if (!SWIG_IsOK(res1)) {
19436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19437 }
19438 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19439 {
19440 PyThreadState* __tstate = wxPyBeginAllowThreads();
19441 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19442 wxPyEndAllowThreads(__tstate);
19443 if (PyErr_Occurred()) SWIG_fail;
19444 }
19445 resultobj = SWIG_From_int(static_cast< int >(result));
19446 return resultobj;
19447 fail:
19448 return NULL;
19449 }
19450
19451
19452 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19453 PyObject *resultobj = 0;
19454 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19455 int result;
19456 void *argp1 = 0 ;
19457 int res1 = 0 ;
19458 PyObject *swig_obj[1] ;
19459
19460 if (!args) SWIG_fail;
19461 swig_obj[0] = args;
19462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19463 if (!SWIG_IsOK(res1)) {
19464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19465 }
19466 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19467 {
19468 PyThreadState* __tstate = wxPyBeginAllowThreads();
19469 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19470 wxPyEndAllowThreads(__tstate);
19471 if (PyErr_Occurred()) SWIG_fail;
19472 }
19473 resultobj = SWIG_From_int(static_cast< int >(result));
19474 return resultobj;
19475 fail:
19476 return NULL;
19477 }
19478
19479
19480 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19481 PyObject *resultobj = 0;
19482 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19483 int arg2 ;
19484 void *argp1 = 0 ;
19485 int res1 = 0 ;
19486 int val2 ;
19487 int ecode2 = 0 ;
19488 PyObject * obj0 = 0 ;
19489 PyObject * obj1 = 0 ;
19490 char * kwnames[] = {
19491 (char *) "self",(char *) "orient", NULL
19492 };
19493
19494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19496 if (!SWIG_IsOK(res1)) {
19497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19498 }
19499 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19500 ecode2 = SWIG_AsVal_int(obj1, &val2);
19501 if (!SWIG_IsOK(ecode2)) {
19502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19503 }
19504 arg2 = static_cast< int >(val2);
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 (arg1)->SetOrientation(arg2);
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 resultobj = SWIG_Py_Void();
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19519 PyObject *resultobj = 0;
19520 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19521 int arg2 ;
19522 void *argp1 = 0 ;
19523 int res1 = 0 ;
19524 int val2 ;
19525 int ecode2 = 0 ;
19526 PyObject * obj0 = 0 ;
19527 PyObject * obj1 = 0 ;
19528 char * kwnames[] = {
19529 (char *) "self",(char *) "pos", NULL
19530 };
19531
19532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19534 if (!SWIG_IsOK(res1)) {
19535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19536 }
19537 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19538 ecode2 = SWIG_AsVal_int(obj1, &val2);
19539 if (!SWIG_IsOK(ecode2)) {
19540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19541 }
19542 arg2 = static_cast< int >(val2);
19543 {
19544 PyThreadState* __tstate = wxPyBeginAllowThreads();
19545 (arg1)->SetPosition(arg2);
19546 wxPyEndAllowThreads(__tstate);
19547 if (PyErr_Occurred()) SWIG_fail;
19548 }
19549 resultobj = SWIG_Py_Void();
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19557 PyObject *obj;
19558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19559 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19560 return SWIG_Py_Void();
19561 }
19562
19563 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19564 return SWIG_Python_InitShadowInstance(args);
19565 }
19566
19567 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19568 PyObject *resultobj = 0;
19569 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19570 int arg2 = (int) 0 ;
19571 int arg3 = (int) 0 ;
19572 wxScrollWinEvent *result = 0 ;
19573 int val1 ;
19574 int ecode1 = 0 ;
19575 int val2 ;
19576 int ecode2 = 0 ;
19577 int val3 ;
19578 int ecode3 = 0 ;
19579 PyObject * obj0 = 0 ;
19580 PyObject * obj1 = 0 ;
19581 PyObject * obj2 = 0 ;
19582 char * kwnames[] = {
19583 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19584 };
19585
19586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19587 if (obj0) {
19588 ecode1 = SWIG_AsVal_int(obj0, &val1);
19589 if (!SWIG_IsOK(ecode1)) {
19590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19591 }
19592 arg1 = static_cast< wxEventType >(val1);
19593 }
19594 if (obj1) {
19595 ecode2 = SWIG_AsVal_int(obj1, &val2);
19596 if (!SWIG_IsOK(ecode2)) {
19597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19598 }
19599 arg2 = static_cast< int >(val2);
19600 }
19601 if (obj2) {
19602 ecode3 = SWIG_AsVal_int(obj2, &val3);
19603 if (!SWIG_IsOK(ecode3)) {
19604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19605 }
19606 arg3 = static_cast< int >(val3);
19607 }
19608 {
19609 PyThreadState* __tstate = wxPyBeginAllowThreads();
19610 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19611 wxPyEndAllowThreads(__tstate);
19612 if (PyErr_Occurred()) SWIG_fail;
19613 }
19614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19615 return resultobj;
19616 fail:
19617 return NULL;
19618 }
19619
19620
19621 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19622 PyObject *resultobj = 0;
19623 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19624 int result;
19625 void *argp1 = 0 ;
19626 int res1 = 0 ;
19627 PyObject *swig_obj[1] ;
19628
19629 if (!args) SWIG_fail;
19630 swig_obj[0] = args;
19631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19632 if (!SWIG_IsOK(res1)) {
19633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19634 }
19635 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 resultobj = SWIG_From_int(static_cast< int >(result));
19643 return resultobj;
19644 fail:
19645 return NULL;
19646 }
19647
19648
19649 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19650 PyObject *resultobj = 0;
19651 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19652 int result;
19653 void *argp1 = 0 ;
19654 int res1 = 0 ;
19655 PyObject *swig_obj[1] ;
19656
19657 if (!args) SWIG_fail;
19658 swig_obj[0] = args;
19659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19660 if (!SWIG_IsOK(res1)) {
19661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19662 }
19663 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19664 {
19665 PyThreadState* __tstate = wxPyBeginAllowThreads();
19666 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19667 wxPyEndAllowThreads(__tstate);
19668 if (PyErr_Occurred()) SWIG_fail;
19669 }
19670 resultobj = SWIG_From_int(static_cast< int >(result));
19671 return resultobj;
19672 fail:
19673 return NULL;
19674 }
19675
19676
19677 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19678 PyObject *resultobj = 0;
19679 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19680 int arg2 ;
19681 void *argp1 = 0 ;
19682 int res1 = 0 ;
19683 int val2 ;
19684 int ecode2 = 0 ;
19685 PyObject * obj0 = 0 ;
19686 PyObject * obj1 = 0 ;
19687 char * kwnames[] = {
19688 (char *) "self",(char *) "orient", NULL
19689 };
19690
19691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19693 if (!SWIG_IsOK(res1)) {
19694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19695 }
19696 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19697 ecode2 = SWIG_AsVal_int(obj1, &val2);
19698 if (!SWIG_IsOK(ecode2)) {
19699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19700 }
19701 arg2 = static_cast< int >(val2);
19702 {
19703 PyThreadState* __tstate = wxPyBeginAllowThreads();
19704 (arg1)->SetOrientation(arg2);
19705 wxPyEndAllowThreads(__tstate);
19706 if (PyErr_Occurred()) SWIG_fail;
19707 }
19708 resultobj = SWIG_Py_Void();
19709 return resultobj;
19710 fail:
19711 return NULL;
19712 }
19713
19714
19715 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19716 PyObject *resultobj = 0;
19717 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19718 int arg2 ;
19719 void *argp1 = 0 ;
19720 int res1 = 0 ;
19721 int val2 ;
19722 int ecode2 = 0 ;
19723 PyObject * obj0 = 0 ;
19724 PyObject * obj1 = 0 ;
19725 char * kwnames[] = {
19726 (char *) "self",(char *) "pos", NULL
19727 };
19728
19729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19731 if (!SWIG_IsOK(res1)) {
19732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19733 }
19734 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19735 ecode2 = SWIG_AsVal_int(obj1, &val2);
19736 if (!SWIG_IsOK(ecode2)) {
19737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19738 }
19739 arg2 = static_cast< int >(val2);
19740 {
19741 PyThreadState* __tstate = wxPyBeginAllowThreads();
19742 (arg1)->SetPosition(arg2);
19743 wxPyEndAllowThreads(__tstate);
19744 if (PyErr_Occurred()) SWIG_fail;
19745 }
19746 resultobj = SWIG_Py_Void();
19747 return resultobj;
19748 fail:
19749 return NULL;
19750 }
19751
19752
19753 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19754 PyObject *obj;
19755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19756 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19757 return SWIG_Py_Void();
19758 }
19759
19760 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19761 return SWIG_Python_InitShadowInstance(args);
19762 }
19763
19764 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19765 PyObject *resultobj = 0;
19766 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19767 wxMouseEvent *result = 0 ;
19768 int val1 ;
19769 int ecode1 = 0 ;
19770 PyObject * obj0 = 0 ;
19771 char * kwnames[] = {
19772 (char *) "mouseType", NULL
19773 };
19774
19775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19776 if (obj0) {
19777 ecode1 = SWIG_AsVal_int(obj0, &val1);
19778 if (!SWIG_IsOK(ecode1)) {
19779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19780 }
19781 arg1 = static_cast< wxEventType >(val1);
19782 }
19783 {
19784 PyThreadState* __tstate = wxPyBeginAllowThreads();
19785 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19786 wxPyEndAllowThreads(__tstate);
19787 if (PyErr_Occurred()) SWIG_fail;
19788 }
19789 {
19790 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19791 }
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19799 PyObject *resultobj = 0;
19800 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19801 bool result;
19802 void *argp1 = 0 ;
19803 int res1 = 0 ;
19804 PyObject *swig_obj[1] ;
19805
19806 if (!args) SWIG_fail;
19807 swig_obj[0] = args;
19808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19809 if (!SWIG_IsOK(res1)) {
19810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19811 }
19812 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19813 {
19814 PyThreadState* __tstate = wxPyBeginAllowThreads();
19815 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19816 wxPyEndAllowThreads(__tstate);
19817 if (PyErr_Occurred()) SWIG_fail;
19818 }
19819 {
19820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19821 }
19822 return resultobj;
19823 fail:
19824 return NULL;
19825 }
19826
19827
19828 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19829 PyObject *resultobj = 0;
19830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19831 int arg2 = (int) wxMOUSE_BTN_ANY ;
19832 bool result;
19833 void *argp1 = 0 ;
19834 int res1 = 0 ;
19835 int val2 ;
19836 int ecode2 = 0 ;
19837 PyObject * obj0 = 0 ;
19838 PyObject * obj1 = 0 ;
19839 char * kwnames[] = {
19840 (char *) "self",(char *) "but", NULL
19841 };
19842
19843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19845 if (!SWIG_IsOK(res1)) {
19846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19847 }
19848 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19849 if (obj1) {
19850 ecode2 = SWIG_AsVal_int(obj1, &val2);
19851 if (!SWIG_IsOK(ecode2)) {
19852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19853 }
19854 arg2 = static_cast< int >(val2);
19855 }
19856 {
19857 PyThreadState* __tstate = wxPyBeginAllowThreads();
19858 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19859 wxPyEndAllowThreads(__tstate);
19860 if (PyErr_Occurred()) SWIG_fail;
19861 }
19862 {
19863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19864 }
19865 return resultobj;
19866 fail:
19867 return NULL;
19868 }
19869
19870
19871 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj = 0;
19873 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19874 int arg2 = (int) wxMOUSE_BTN_ANY ;
19875 bool result;
19876 void *argp1 = 0 ;
19877 int res1 = 0 ;
19878 int val2 ;
19879 int ecode2 = 0 ;
19880 PyObject * obj0 = 0 ;
19881 PyObject * obj1 = 0 ;
19882 char * kwnames[] = {
19883 (char *) "self",(char *) "but", NULL
19884 };
19885
19886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19888 if (!SWIG_IsOK(res1)) {
19889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19890 }
19891 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19892 if (obj1) {
19893 ecode2 = SWIG_AsVal_int(obj1, &val2);
19894 if (!SWIG_IsOK(ecode2)) {
19895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19896 }
19897 arg2 = static_cast< int >(val2);
19898 }
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19902 wxPyEndAllowThreads(__tstate);
19903 if (PyErr_Occurred()) SWIG_fail;
19904 }
19905 {
19906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19907 }
19908 return resultobj;
19909 fail:
19910 return NULL;
19911 }
19912
19913
19914 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19915 PyObject *resultobj = 0;
19916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19917 int arg2 = (int) wxMOUSE_BTN_ANY ;
19918 bool result;
19919 void *argp1 = 0 ;
19920 int res1 = 0 ;
19921 int val2 ;
19922 int ecode2 = 0 ;
19923 PyObject * obj0 = 0 ;
19924 PyObject * obj1 = 0 ;
19925 char * kwnames[] = {
19926 (char *) "self",(char *) "but", NULL
19927 };
19928
19929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19931 if (!SWIG_IsOK(res1)) {
19932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19933 }
19934 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19935 if (obj1) {
19936 ecode2 = SWIG_AsVal_int(obj1, &val2);
19937 if (!SWIG_IsOK(ecode2)) {
19938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19939 }
19940 arg2 = static_cast< int >(val2);
19941 }
19942 {
19943 PyThreadState* __tstate = wxPyBeginAllowThreads();
19944 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19945 wxPyEndAllowThreads(__tstate);
19946 if (PyErr_Occurred()) SWIG_fail;
19947 }
19948 {
19949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19950 }
19951 return resultobj;
19952 fail:
19953 return NULL;
19954 }
19955
19956
19957 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19958 PyObject *resultobj = 0;
19959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19960 int arg2 ;
19961 bool result;
19962 void *argp1 = 0 ;
19963 int res1 = 0 ;
19964 int val2 ;
19965 int ecode2 = 0 ;
19966 PyObject * obj0 = 0 ;
19967 PyObject * obj1 = 0 ;
19968 char * kwnames[] = {
19969 (char *) "self",(char *) "button", NULL
19970 };
19971
19972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19974 if (!SWIG_IsOK(res1)) {
19975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19976 }
19977 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19978 ecode2 = SWIG_AsVal_int(obj1, &val2);
19979 if (!SWIG_IsOK(ecode2)) {
19980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19981 }
19982 arg2 = static_cast< int >(val2);
19983 {
19984 PyThreadState* __tstate = wxPyBeginAllowThreads();
19985 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19986 wxPyEndAllowThreads(__tstate);
19987 if (PyErr_Occurred()) SWIG_fail;
19988 }
19989 {
19990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19991 }
19992 return resultobj;
19993 fail:
19994 return NULL;
19995 }
19996
19997
19998 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj = 0;
20000 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20001 int arg2 ;
20002 bool result;
20003 void *argp1 = 0 ;
20004 int res1 = 0 ;
20005 int val2 ;
20006 int ecode2 = 0 ;
20007 PyObject * obj0 = 0 ;
20008 PyObject * obj1 = 0 ;
20009 char * kwnames[] = {
20010 (char *) "self",(char *) "but", NULL
20011 };
20012
20013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20015 if (!SWIG_IsOK(res1)) {
20016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20017 }
20018 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20019 ecode2 = SWIG_AsVal_int(obj1, &val2);
20020 if (!SWIG_IsOK(ecode2)) {
20021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20022 }
20023 arg2 = static_cast< int >(val2);
20024 {
20025 PyThreadState* __tstate = wxPyBeginAllowThreads();
20026 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20027 wxPyEndAllowThreads(__tstate);
20028 if (PyErr_Occurred()) SWIG_fail;
20029 }
20030 {
20031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20032 }
20033 return resultobj;
20034 fail:
20035 return NULL;
20036 }
20037
20038
20039 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20040 PyObject *resultobj = 0;
20041 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20042 int result;
20043 void *argp1 = 0 ;
20044 int res1 = 0 ;
20045 PyObject *swig_obj[1] ;
20046
20047 if (!args) SWIG_fail;
20048 swig_obj[0] = args;
20049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20050 if (!SWIG_IsOK(res1)) {
20051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20052 }
20053 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20054 {
20055 PyThreadState* __tstate = wxPyBeginAllowThreads();
20056 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20057 wxPyEndAllowThreads(__tstate);
20058 if (PyErr_Occurred()) SWIG_fail;
20059 }
20060 resultobj = SWIG_From_int(static_cast< int >(result));
20061 return resultobj;
20062 fail:
20063 return NULL;
20064 }
20065
20066
20067 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20068 PyObject *resultobj = 0;
20069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20070 bool result;
20071 void *argp1 = 0 ;
20072 int res1 = 0 ;
20073 PyObject *swig_obj[1] ;
20074
20075 if (!args) SWIG_fail;
20076 swig_obj[0] = args;
20077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20078 if (!SWIG_IsOK(res1)) {
20079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20080 }
20081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20082 {
20083 PyThreadState* __tstate = wxPyBeginAllowThreads();
20084 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20085 wxPyEndAllowThreads(__tstate);
20086 if (PyErr_Occurred()) SWIG_fail;
20087 }
20088 {
20089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20090 }
20091 return resultobj;
20092 fail:
20093 return NULL;
20094 }
20095
20096
20097 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20098 PyObject *resultobj = 0;
20099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20100 bool result;
20101 void *argp1 = 0 ;
20102 int res1 = 0 ;
20103 PyObject *swig_obj[1] ;
20104
20105 if (!args) SWIG_fail;
20106 swig_obj[0] = args;
20107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20108 if (!SWIG_IsOK(res1)) {
20109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20110 }
20111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20112 {
20113 PyThreadState* __tstate = wxPyBeginAllowThreads();
20114 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20115 wxPyEndAllowThreads(__tstate);
20116 if (PyErr_Occurred()) SWIG_fail;
20117 }
20118 {
20119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20120 }
20121 return resultobj;
20122 fail:
20123 return NULL;
20124 }
20125
20126
20127 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20128 PyObject *resultobj = 0;
20129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20130 bool result;
20131 void *argp1 = 0 ;
20132 int res1 = 0 ;
20133 PyObject *swig_obj[1] ;
20134
20135 if (!args) SWIG_fail;
20136 swig_obj[0] = args;
20137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20138 if (!SWIG_IsOK(res1)) {
20139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20140 }
20141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20142 {
20143 PyThreadState* __tstate = wxPyBeginAllowThreads();
20144 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20145 wxPyEndAllowThreads(__tstate);
20146 if (PyErr_Occurred()) SWIG_fail;
20147 }
20148 {
20149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20150 }
20151 return resultobj;
20152 fail:
20153 return NULL;
20154 }
20155
20156
20157 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20158 PyObject *resultobj = 0;
20159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20160 bool result;
20161 void *argp1 = 0 ;
20162 int res1 = 0 ;
20163 PyObject *swig_obj[1] ;
20164
20165 if (!args) SWIG_fail;
20166 swig_obj[0] = args;
20167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20168 if (!SWIG_IsOK(res1)) {
20169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20170 }
20171 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20172 {
20173 PyThreadState* __tstate = wxPyBeginAllowThreads();
20174 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20175 wxPyEndAllowThreads(__tstate);
20176 if (PyErr_Occurred()) SWIG_fail;
20177 }
20178 {
20179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20180 }
20181 return resultobj;
20182 fail:
20183 return NULL;
20184 }
20185
20186
20187 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20188 PyObject *resultobj = 0;
20189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20190 bool result;
20191 void *argp1 = 0 ;
20192 int res1 = 0 ;
20193 PyObject *swig_obj[1] ;
20194
20195 if (!args) SWIG_fail;
20196 swig_obj[0] = args;
20197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20198 if (!SWIG_IsOK(res1)) {
20199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20200 }
20201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20202 {
20203 PyThreadState* __tstate = wxPyBeginAllowThreads();
20204 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20205 wxPyEndAllowThreads(__tstate);
20206 if (PyErr_Occurred()) SWIG_fail;
20207 }
20208 {
20209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20210 }
20211 return resultobj;
20212 fail:
20213 return NULL;
20214 }
20215
20216
20217 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20218 PyObject *resultobj = 0;
20219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20220 bool result;
20221 void *argp1 = 0 ;
20222 int res1 = 0 ;
20223 PyObject *swig_obj[1] ;
20224
20225 if (!args) SWIG_fail;
20226 swig_obj[0] = args;
20227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20228 if (!SWIG_IsOK(res1)) {
20229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20230 }
20231 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20232 {
20233 PyThreadState* __tstate = wxPyBeginAllowThreads();
20234 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20235 wxPyEndAllowThreads(__tstate);
20236 if (PyErr_Occurred()) SWIG_fail;
20237 }
20238 {
20239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20240 }
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20248 PyObject *resultobj = 0;
20249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20250 bool result;
20251 void *argp1 = 0 ;
20252 int res1 = 0 ;
20253 PyObject *swig_obj[1] ;
20254
20255 if (!args) SWIG_fail;
20256 swig_obj[0] = args;
20257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20258 if (!SWIG_IsOK(res1)) {
20259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20260 }
20261 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 {
20269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20270 }
20271 return resultobj;
20272 fail:
20273 return NULL;
20274 }
20275
20276
20277 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20278 PyObject *resultobj = 0;
20279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20280 bool result;
20281 void *argp1 = 0 ;
20282 int res1 = 0 ;
20283 PyObject *swig_obj[1] ;
20284
20285 if (!args) SWIG_fail;
20286 swig_obj[0] = args;
20287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20288 if (!SWIG_IsOK(res1)) {
20289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20290 }
20291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 {
20299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20300 }
20301 return resultobj;
20302 fail:
20303 return NULL;
20304 }
20305
20306
20307 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20308 PyObject *resultobj = 0;
20309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20310 bool result;
20311 void *argp1 = 0 ;
20312 int res1 = 0 ;
20313 PyObject *swig_obj[1] ;
20314
20315 if (!args) SWIG_fail;
20316 swig_obj[0] = args;
20317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20318 if (!SWIG_IsOK(res1)) {
20319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20320 }
20321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20322 {
20323 PyThreadState* __tstate = wxPyBeginAllowThreads();
20324 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 {
20329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20330 }
20331 return resultobj;
20332 fail:
20333 return NULL;
20334 }
20335
20336
20337 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20338 PyObject *resultobj = 0;
20339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20340 bool result;
20341 void *argp1 = 0 ;
20342 int res1 = 0 ;
20343 PyObject *swig_obj[1] ;
20344
20345 if (!args) SWIG_fail;
20346 swig_obj[0] = args;
20347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20348 if (!SWIG_IsOK(res1)) {
20349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20350 }
20351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20352 {
20353 PyThreadState* __tstate = wxPyBeginAllowThreads();
20354 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 {
20359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20360 }
20361 return resultobj;
20362 fail:
20363 return NULL;
20364 }
20365
20366
20367 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20368 PyObject *resultobj = 0;
20369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20370 bool result;
20371 void *argp1 = 0 ;
20372 int res1 = 0 ;
20373 PyObject *swig_obj[1] ;
20374
20375 if (!args) SWIG_fail;
20376 swig_obj[0] = args;
20377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20378 if (!SWIG_IsOK(res1)) {
20379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20380 }
20381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20382 {
20383 PyThreadState* __tstate = wxPyBeginAllowThreads();
20384 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20385 wxPyEndAllowThreads(__tstate);
20386 if (PyErr_Occurred()) SWIG_fail;
20387 }
20388 {
20389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20390 }
20391 return resultobj;
20392 fail:
20393 return NULL;
20394 }
20395
20396
20397 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20398 PyObject *resultobj = 0;
20399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20400 bool result;
20401 void *argp1 = 0 ;
20402 int res1 = 0 ;
20403 PyObject *swig_obj[1] ;
20404
20405 if (!args) SWIG_fail;
20406 swig_obj[0] = args;
20407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20408 if (!SWIG_IsOK(res1)) {
20409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20410 }
20411 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20412 {
20413 PyThreadState* __tstate = wxPyBeginAllowThreads();
20414 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20415 wxPyEndAllowThreads(__tstate);
20416 if (PyErr_Occurred()) SWIG_fail;
20417 }
20418 {
20419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20420 }
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20428 PyObject *resultobj = 0;
20429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20430 bool result;
20431 void *argp1 = 0 ;
20432 int res1 = 0 ;
20433 PyObject *swig_obj[1] ;
20434
20435 if (!args) SWIG_fail;
20436 swig_obj[0] = args;
20437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20438 if (!SWIG_IsOK(res1)) {
20439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20440 }
20441 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20442 {
20443 PyThreadState* __tstate = wxPyBeginAllowThreads();
20444 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20445 wxPyEndAllowThreads(__tstate);
20446 if (PyErr_Occurred()) SWIG_fail;
20447 }
20448 {
20449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20450 }
20451 return resultobj;
20452 fail:
20453 return NULL;
20454 }
20455
20456
20457 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20458 PyObject *resultobj = 0;
20459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20460 bool result;
20461 void *argp1 = 0 ;
20462 int res1 = 0 ;
20463 PyObject *swig_obj[1] ;
20464
20465 if (!args) SWIG_fail;
20466 swig_obj[0] = args;
20467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20468 if (!SWIG_IsOK(res1)) {
20469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20470 }
20471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20472 {
20473 PyThreadState* __tstate = wxPyBeginAllowThreads();
20474 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20475 wxPyEndAllowThreads(__tstate);
20476 if (PyErr_Occurred()) SWIG_fail;
20477 }
20478 {
20479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20480 }
20481 return resultobj;
20482 fail:
20483 return NULL;
20484 }
20485
20486
20487 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20488 PyObject *resultobj = 0;
20489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20490 bool result;
20491 void *argp1 = 0 ;
20492 int res1 = 0 ;
20493 PyObject *swig_obj[1] ;
20494
20495 if (!args) SWIG_fail;
20496 swig_obj[0] = args;
20497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20498 if (!SWIG_IsOK(res1)) {
20499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20500 }
20501 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20502 {
20503 PyThreadState* __tstate = wxPyBeginAllowThreads();
20504 result = (bool)(arg1)->LeftIsDown();
20505 wxPyEndAllowThreads(__tstate);
20506 if (PyErr_Occurred()) SWIG_fail;
20507 }
20508 {
20509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20510 }
20511 return resultobj;
20512 fail:
20513 return NULL;
20514 }
20515
20516
20517 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20518 PyObject *resultobj = 0;
20519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20520 bool result;
20521 void *argp1 = 0 ;
20522 int res1 = 0 ;
20523 PyObject *swig_obj[1] ;
20524
20525 if (!args) SWIG_fail;
20526 swig_obj[0] = args;
20527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20528 if (!SWIG_IsOK(res1)) {
20529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20530 }
20531 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20532 {
20533 PyThreadState* __tstate = wxPyBeginAllowThreads();
20534 result = (bool)(arg1)->MiddleIsDown();
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20540 }
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20548 PyObject *resultobj = 0;
20549 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20550 bool result;
20551 void *argp1 = 0 ;
20552 int res1 = 0 ;
20553 PyObject *swig_obj[1] ;
20554
20555 if (!args) SWIG_fail;
20556 swig_obj[0] = args;
20557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20558 if (!SWIG_IsOK(res1)) {
20559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20560 }
20561 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20562 {
20563 PyThreadState* __tstate = wxPyBeginAllowThreads();
20564 result = (bool)(arg1)->RightIsDown();
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 {
20569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20570 }
20571 return resultobj;
20572 fail:
20573 return NULL;
20574 }
20575
20576
20577 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20578 PyObject *resultobj = 0;
20579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20580 bool result;
20581 void *argp1 = 0 ;
20582 int res1 = 0 ;
20583 PyObject *swig_obj[1] ;
20584
20585 if (!args) SWIG_fail;
20586 swig_obj[0] = args;
20587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20588 if (!SWIG_IsOK(res1)) {
20589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20590 }
20591 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20592 {
20593 PyThreadState* __tstate = wxPyBeginAllowThreads();
20594 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20595 wxPyEndAllowThreads(__tstate);
20596 if (PyErr_Occurred()) SWIG_fail;
20597 }
20598 {
20599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20600 }
20601 return resultobj;
20602 fail:
20603 return NULL;
20604 }
20605
20606
20607 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20608 PyObject *resultobj = 0;
20609 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20610 bool result;
20611 void *argp1 = 0 ;
20612 int res1 = 0 ;
20613 PyObject *swig_obj[1] ;
20614
20615 if (!args) SWIG_fail;
20616 swig_obj[0] = args;
20617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20618 if (!SWIG_IsOK(res1)) {
20619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20620 }
20621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20622 {
20623 PyThreadState* __tstate = wxPyBeginAllowThreads();
20624 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20625 wxPyEndAllowThreads(__tstate);
20626 if (PyErr_Occurred()) SWIG_fail;
20627 }
20628 {
20629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20630 }
20631 return resultobj;
20632 fail:
20633 return NULL;
20634 }
20635
20636
20637 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20638 PyObject *resultobj = 0;
20639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20640 bool result;
20641 void *argp1 = 0 ;
20642 int res1 = 0 ;
20643 PyObject *swig_obj[1] ;
20644
20645 if (!args) SWIG_fail;
20646 swig_obj[0] = args;
20647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20648 if (!SWIG_IsOK(res1)) {
20649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20650 }
20651 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20652 {
20653 PyThreadState* __tstate = wxPyBeginAllowThreads();
20654 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20655 wxPyEndAllowThreads(__tstate);
20656 if (PyErr_Occurred()) SWIG_fail;
20657 }
20658 {
20659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20660 }
20661 return resultobj;
20662 fail:
20663 return NULL;
20664 }
20665
20666
20667 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20668 PyObject *resultobj = 0;
20669 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20670 bool result;
20671 void *argp1 = 0 ;
20672 int res1 = 0 ;
20673 PyObject *swig_obj[1] ;
20674
20675 if (!args) SWIG_fail;
20676 swig_obj[0] = args;
20677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20678 if (!SWIG_IsOK(res1)) {
20679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20680 }
20681 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20682 {
20683 PyThreadState* __tstate = wxPyBeginAllowThreads();
20684 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 {
20689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20690 }
20691 return resultobj;
20692 fail:
20693 return NULL;
20694 }
20695
20696
20697 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20698 PyObject *resultobj = 0;
20699 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20700 wxPoint result;
20701 void *argp1 = 0 ;
20702 int res1 = 0 ;
20703 PyObject *swig_obj[1] ;
20704
20705 if (!args) SWIG_fail;
20706 swig_obj[0] = args;
20707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20708 if (!SWIG_IsOK(res1)) {
20709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20710 }
20711 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20712 {
20713 PyThreadState* __tstate = wxPyBeginAllowThreads();
20714 result = (arg1)->GetPosition();
20715 wxPyEndAllowThreads(__tstate);
20716 if (PyErr_Occurred()) SWIG_fail;
20717 }
20718 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20719 return resultobj;
20720 fail:
20721 return NULL;
20722 }
20723
20724
20725 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20726 PyObject *resultobj = 0;
20727 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20728 long *arg2 = (long *) 0 ;
20729 long *arg3 = (long *) 0 ;
20730 void *argp1 = 0 ;
20731 int res1 = 0 ;
20732 long temp2 ;
20733 int res2 = SWIG_TMPOBJ ;
20734 long temp3 ;
20735 int res3 = SWIG_TMPOBJ ;
20736 PyObject *swig_obj[1] ;
20737
20738 arg2 = &temp2;
20739 arg3 = &temp3;
20740 if (!args) SWIG_fail;
20741 swig_obj[0] = args;
20742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20743 if (!SWIG_IsOK(res1)) {
20744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20745 }
20746 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 (arg1)->GetPosition(arg2,arg3);
20750 wxPyEndAllowThreads(__tstate);
20751 if (PyErr_Occurred()) SWIG_fail;
20752 }
20753 resultobj = SWIG_Py_Void();
20754 if (SWIG_IsTmpObj(res2)) {
20755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20756 } else {
20757 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20759 }
20760 if (SWIG_IsTmpObj(res3)) {
20761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20762 } else {
20763 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20765 }
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20773 PyObject *resultobj = 0;
20774 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20775 wxDC *arg2 = 0 ;
20776 wxPoint result;
20777 void *argp1 = 0 ;
20778 int res1 = 0 ;
20779 void *argp2 = 0 ;
20780 int res2 = 0 ;
20781 PyObject * obj0 = 0 ;
20782 PyObject * obj1 = 0 ;
20783 char * kwnames[] = {
20784 (char *) "self",(char *) "dc", NULL
20785 };
20786
20787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20789 if (!SWIG_IsOK(res1)) {
20790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20791 }
20792 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20793 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20794 if (!SWIG_IsOK(res2)) {
20795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20796 }
20797 if (!argp2) {
20798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20799 }
20800 arg2 = reinterpret_cast< wxDC * >(argp2);
20801 {
20802 PyThreadState* __tstate = wxPyBeginAllowThreads();
20803 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20808 return resultobj;
20809 fail:
20810 return NULL;
20811 }
20812
20813
20814 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20815 PyObject *resultobj = 0;
20816 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20817 int result;
20818 void *argp1 = 0 ;
20819 int res1 = 0 ;
20820 PyObject *swig_obj[1] ;
20821
20822 if (!args) SWIG_fail;
20823 swig_obj[0] = args;
20824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20825 if (!SWIG_IsOK(res1)) {
20826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20827 }
20828 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 result = (int)((wxMouseEvent const *)arg1)->GetX();
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 resultobj = SWIG_From_int(static_cast< int >(result));
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20843 PyObject *resultobj = 0;
20844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20845 int result;
20846 void *argp1 = 0 ;
20847 int res1 = 0 ;
20848 PyObject *swig_obj[1] ;
20849
20850 if (!args) SWIG_fail;
20851 swig_obj[0] = args;
20852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20853 if (!SWIG_IsOK(res1)) {
20854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20855 }
20856 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20857 {
20858 PyThreadState* __tstate = wxPyBeginAllowThreads();
20859 result = (int)((wxMouseEvent const *)arg1)->GetY();
20860 wxPyEndAllowThreads(__tstate);
20861 if (PyErr_Occurred()) SWIG_fail;
20862 }
20863 resultobj = SWIG_From_int(static_cast< int >(result));
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20871 PyObject *resultobj = 0;
20872 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20873 int result;
20874 void *argp1 = 0 ;
20875 int res1 = 0 ;
20876 PyObject *swig_obj[1] ;
20877
20878 if (!args) SWIG_fail;
20879 swig_obj[0] = args;
20880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20881 if (!SWIG_IsOK(res1)) {
20882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20883 }
20884 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20885 {
20886 PyThreadState* __tstate = wxPyBeginAllowThreads();
20887 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20888 wxPyEndAllowThreads(__tstate);
20889 if (PyErr_Occurred()) SWIG_fail;
20890 }
20891 resultobj = SWIG_From_int(static_cast< int >(result));
20892 return resultobj;
20893 fail:
20894 return NULL;
20895 }
20896
20897
20898 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20899 PyObject *resultobj = 0;
20900 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20901 int result;
20902 void *argp1 = 0 ;
20903 int res1 = 0 ;
20904 PyObject *swig_obj[1] ;
20905
20906 if (!args) SWIG_fail;
20907 swig_obj[0] = args;
20908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20909 if (!SWIG_IsOK(res1)) {
20910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20911 }
20912 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20913 {
20914 PyThreadState* __tstate = wxPyBeginAllowThreads();
20915 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20916 wxPyEndAllowThreads(__tstate);
20917 if (PyErr_Occurred()) SWIG_fail;
20918 }
20919 resultobj = SWIG_From_int(static_cast< int >(result));
20920 return resultobj;
20921 fail:
20922 return NULL;
20923 }
20924
20925
20926 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20927 PyObject *resultobj = 0;
20928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20929 int 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_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20939 }
20940 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 resultobj = SWIG_From_int(static_cast< int >(result));
20948 return resultobj;
20949 fail:
20950 return NULL;
20951 }
20952
20953
20954 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20955 PyObject *resultobj = 0;
20956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20957 bool result;
20958 void *argp1 = 0 ;
20959 int res1 = 0 ;
20960 PyObject *swig_obj[1] ;
20961
20962 if (!args) SWIG_fail;
20963 swig_obj[0] = args;
20964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20965 if (!SWIG_IsOK(res1)) {
20966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20967 }
20968 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20969 {
20970 PyThreadState* __tstate = wxPyBeginAllowThreads();
20971 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 {
20976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20977 }
20978 return resultobj;
20979 fail:
20980 return NULL;
20981 }
20982
20983
20984 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20985 PyObject *resultobj = 0;
20986 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20987 int arg2 ;
20988 void *argp1 = 0 ;
20989 int res1 = 0 ;
20990 int val2 ;
20991 int ecode2 = 0 ;
20992 PyObject *swig_obj[2] ;
20993
20994 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20996 if (!SWIG_IsOK(res1)) {
20997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20998 }
20999 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21000 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21001 if (!SWIG_IsOK(ecode2)) {
21002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21003 }
21004 arg2 = static_cast< int >(val2);
21005 if (arg1) (arg1)->m_x = arg2;
21006
21007 resultobj = SWIG_Py_Void();
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21015 PyObject *resultobj = 0;
21016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21017 int result;
21018 void *argp1 = 0 ;
21019 int res1 = 0 ;
21020 PyObject *swig_obj[1] ;
21021
21022 if (!args) SWIG_fail;
21023 swig_obj[0] = args;
21024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21025 if (!SWIG_IsOK(res1)) {
21026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21027 }
21028 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21029 result = (int) ((arg1)->m_x);
21030 resultobj = SWIG_From_int(static_cast< int >(result));
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21038 PyObject *resultobj = 0;
21039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21040 int arg2 ;
21041 void *argp1 = 0 ;
21042 int res1 = 0 ;
21043 int val2 ;
21044 int ecode2 = 0 ;
21045 PyObject *swig_obj[2] ;
21046
21047 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21049 if (!SWIG_IsOK(res1)) {
21050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21051 }
21052 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21053 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21054 if (!SWIG_IsOK(ecode2)) {
21055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21056 }
21057 arg2 = static_cast< int >(val2);
21058 if (arg1) (arg1)->m_y = arg2;
21059
21060 resultobj = SWIG_Py_Void();
21061 return resultobj;
21062 fail:
21063 return NULL;
21064 }
21065
21066
21067 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21068 PyObject *resultobj = 0;
21069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21070 int result;
21071 void *argp1 = 0 ;
21072 int res1 = 0 ;
21073 PyObject *swig_obj[1] ;
21074
21075 if (!args) SWIG_fail;
21076 swig_obj[0] = args;
21077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21078 if (!SWIG_IsOK(res1)) {
21079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21080 }
21081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21082 result = (int) ((arg1)->m_y);
21083 resultobj = SWIG_From_int(static_cast< int >(result));
21084 return resultobj;
21085 fail:
21086 return NULL;
21087 }
21088
21089
21090 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21091 PyObject *resultobj = 0;
21092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21093 bool arg2 ;
21094 void *argp1 = 0 ;
21095 int res1 = 0 ;
21096 bool val2 ;
21097 int ecode2 = 0 ;
21098 PyObject *swig_obj[2] ;
21099
21100 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21102 if (!SWIG_IsOK(res1)) {
21103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21104 }
21105 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21106 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21107 if (!SWIG_IsOK(ecode2)) {
21108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21109 }
21110 arg2 = static_cast< bool >(val2);
21111 if (arg1) (arg1)->m_leftDown = arg2;
21112
21113 resultobj = SWIG_Py_Void();
21114 return resultobj;
21115 fail:
21116 return NULL;
21117 }
21118
21119
21120 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21121 PyObject *resultobj = 0;
21122 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21123 bool result;
21124 void *argp1 = 0 ;
21125 int res1 = 0 ;
21126 PyObject *swig_obj[1] ;
21127
21128 if (!args) SWIG_fail;
21129 swig_obj[0] = args;
21130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21131 if (!SWIG_IsOK(res1)) {
21132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21133 }
21134 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21135 result = (bool) ((arg1)->m_leftDown);
21136 {
21137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21138 }
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21148 bool arg2 ;
21149 void *argp1 = 0 ;
21150 int res1 = 0 ;
21151 bool val2 ;
21152 int ecode2 = 0 ;
21153 PyObject *swig_obj[2] ;
21154
21155 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21159 }
21160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21161 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21162 if (!SWIG_IsOK(ecode2)) {
21163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21164 }
21165 arg2 = static_cast< bool >(val2);
21166 if (arg1) (arg1)->m_middleDown = arg2;
21167
21168 resultobj = SWIG_Py_Void();
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21176 PyObject *resultobj = 0;
21177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21178 bool result;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 PyObject *swig_obj[1] ;
21182
21183 if (!args) SWIG_fail;
21184 swig_obj[0] = args;
21185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21188 }
21189 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21190 result = (bool) ((arg1)->m_middleDown);
21191 {
21192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21193 }
21194 return resultobj;
21195 fail:
21196 return NULL;
21197 }
21198
21199
21200 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21201 PyObject *resultobj = 0;
21202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21203 bool arg2 ;
21204 void *argp1 = 0 ;
21205 int res1 = 0 ;
21206 bool val2 ;
21207 int ecode2 = 0 ;
21208 PyObject *swig_obj[2] ;
21209
21210 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21212 if (!SWIG_IsOK(res1)) {
21213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21214 }
21215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21216 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21217 if (!SWIG_IsOK(ecode2)) {
21218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21219 }
21220 arg2 = static_cast< bool >(val2);
21221 if (arg1) (arg1)->m_rightDown = arg2;
21222
21223 resultobj = SWIG_Py_Void();
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21231 PyObject *resultobj = 0;
21232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21233 bool result;
21234 void *argp1 = 0 ;
21235 int res1 = 0 ;
21236 PyObject *swig_obj[1] ;
21237
21238 if (!args) SWIG_fail;
21239 swig_obj[0] = args;
21240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21241 if (!SWIG_IsOK(res1)) {
21242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21243 }
21244 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21245 result = (bool) ((arg1)->m_rightDown);
21246 {
21247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21248 }
21249 return resultobj;
21250 fail:
21251 return NULL;
21252 }
21253
21254
21255 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21256 PyObject *resultobj = 0;
21257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21258 bool arg2 ;
21259 void *argp1 = 0 ;
21260 int res1 = 0 ;
21261 bool val2 ;
21262 int ecode2 = 0 ;
21263 PyObject *swig_obj[2] ;
21264
21265 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21267 if (!SWIG_IsOK(res1)) {
21268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21269 }
21270 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21271 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21272 if (!SWIG_IsOK(ecode2)) {
21273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21274 }
21275 arg2 = static_cast< bool >(val2);
21276 if (arg1) (arg1)->m_controlDown = arg2;
21277
21278 resultobj = SWIG_Py_Void();
21279 return resultobj;
21280 fail:
21281 return NULL;
21282 }
21283
21284
21285 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21286 PyObject *resultobj = 0;
21287 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21288 bool result;
21289 void *argp1 = 0 ;
21290 int res1 = 0 ;
21291 PyObject *swig_obj[1] ;
21292
21293 if (!args) SWIG_fail;
21294 swig_obj[0] = args;
21295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21296 if (!SWIG_IsOK(res1)) {
21297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21298 }
21299 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21300 result = (bool) ((arg1)->m_controlDown);
21301 {
21302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21303 }
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21311 PyObject *resultobj = 0;
21312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21313 bool arg2 ;
21314 void *argp1 = 0 ;
21315 int res1 = 0 ;
21316 bool val2 ;
21317 int ecode2 = 0 ;
21318 PyObject *swig_obj[2] ;
21319
21320 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21322 if (!SWIG_IsOK(res1)) {
21323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21324 }
21325 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21326 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21327 if (!SWIG_IsOK(ecode2)) {
21328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21329 }
21330 arg2 = static_cast< bool >(val2);
21331 if (arg1) (arg1)->m_shiftDown = arg2;
21332
21333 resultobj = SWIG_Py_Void();
21334 return resultobj;
21335 fail:
21336 return NULL;
21337 }
21338
21339
21340 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21341 PyObject *resultobj = 0;
21342 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21343 bool result;
21344 void *argp1 = 0 ;
21345 int res1 = 0 ;
21346 PyObject *swig_obj[1] ;
21347
21348 if (!args) SWIG_fail;
21349 swig_obj[0] = args;
21350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21351 if (!SWIG_IsOK(res1)) {
21352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21353 }
21354 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21355 result = (bool) ((arg1)->m_shiftDown);
21356 {
21357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21358 }
21359 return resultobj;
21360 fail:
21361 return NULL;
21362 }
21363
21364
21365 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21366 PyObject *resultobj = 0;
21367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21368 bool arg2 ;
21369 void *argp1 = 0 ;
21370 int res1 = 0 ;
21371 bool val2 ;
21372 int ecode2 = 0 ;
21373 PyObject *swig_obj[2] ;
21374
21375 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21377 if (!SWIG_IsOK(res1)) {
21378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21379 }
21380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21381 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21382 if (!SWIG_IsOK(ecode2)) {
21383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21384 }
21385 arg2 = static_cast< bool >(val2);
21386 if (arg1) (arg1)->m_altDown = arg2;
21387
21388 resultobj = SWIG_Py_Void();
21389 return resultobj;
21390 fail:
21391 return NULL;
21392 }
21393
21394
21395 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21396 PyObject *resultobj = 0;
21397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21398 bool result;
21399 void *argp1 = 0 ;
21400 int res1 = 0 ;
21401 PyObject *swig_obj[1] ;
21402
21403 if (!args) SWIG_fail;
21404 swig_obj[0] = args;
21405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21406 if (!SWIG_IsOK(res1)) {
21407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21408 }
21409 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21410 result = (bool) ((arg1)->m_altDown);
21411 {
21412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21413 }
21414 return resultobj;
21415 fail:
21416 return NULL;
21417 }
21418
21419
21420 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21421 PyObject *resultobj = 0;
21422 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21423 bool arg2 ;
21424 void *argp1 = 0 ;
21425 int res1 = 0 ;
21426 bool val2 ;
21427 int ecode2 = 0 ;
21428 PyObject *swig_obj[2] ;
21429
21430 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21432 if (!SWIG_IsOK(res1)) {
21433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21434 }
21435 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21436 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21437 if (!SWIG_IsOK(ecode2)) {
21438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21439 }
21440 arg2 = static_cast< bool >(val2);
21441 if (arg1) (arg1)->m_metaDown = arg2;
21442
21443 resultobj = SWIG_Py_Void();
21444 return resultobj;
21445 fail:
21446 return NULL;
21447 }
21448
21449
21450 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21451 PyObject *resultobj = 0;
21452 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21453 bool result;
21454 void *argp1 = 0 ;
21455 int res1 = 0 ;
21456 PyObject *swig_obj[1] ;
21457
21458 if (!args) SWIG_fail;
21459 swig_obj[0] = args;
21460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21461 if (!SWIG_IsOK(res1)) {
21462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21463 }
21464 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21465 result = (bool) ((arg1)->m_metaDown);
21466 {
21467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21468 }
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21476 PyObject *resultobj = 0;
21477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21478 int arg2 ;
21479 void *argp1 = 0 ;
21480 int res1 = 0 ;
21481 int val2 ;
21482 int ecode2 = 0 ;
21483 PyObject *swig_obj[2] ;
21484
21485 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21487 if (!SWIG_IsOK(res1)) {
21488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21489 }
21490 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21491 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21492 if (!SWIG_IsOK(ecode2)) {
21493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21494 }
21495 arg2 = static_cast< int >(val2);
21496 if (arg1) (arg1)->m_wheelRotation = arg2;
21497
21498 resultobj = SWIG_Py_Void();
21499 return resultobj;
21500 fail:
21501 return NULL;
21502 }
21503
21504
21505 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21506 PyObject *resultobj = 0;
21507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21508 int result;
21509 void *argp1 = 0 ;
21510 int res1 = 0 ;
21511 PyObject *swig_obj[1] ;
21512
21513 if (!args) SWIG_fail;
21514 swig_obj[0] = args;
21515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21516 if (!SWIG_IsOK(res1)) {
21517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21518 }
21519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21520 result = (int) ((arg1)->m_wheelRotation);
21521 resultobj = SWIG_From_int(static_cast< int >(result));
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21529 PyObject *resultobj = 0;
21530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21531 int arg2 ;
21532 void *argp1 = 0 ;
21533 int res1 = 0 ;
21534 int val2 ;
21535 int ecode2 = 0 ;
21536 PyObject *swig_obj[2] ;
21537
21538 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21540 if (!SWIG_IsOK(res1)) {
21541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21542 }
21543 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21544 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21545 if (!SWIG_IsOK(ecode2)) {
21546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21547 }
21548 arg2 = static_cast< int >(val2);
21549 if (arg1) (arg1)->m_wheelDelta = arg2;
21550
21551 resultobj = SWIG_Py_Void();
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 PyObject *resultobj = 0;
21560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21561 int result;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 PyObject *swig_obj[1] ;
21565
21566 if (!args) SWIG_fail;
21567 swig_obj[0] = args;
21568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21569 if (!SWIG_IsOK(res1)) {
21570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21571 }
21572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21573 result = (int) ((arg1)->m_wheelDelta);
21574 resultobj = SWIG_From_int(static_cast< int >(result));
21575 return resultobj;
21576 fail:
21577 return NULL;
21578 }
21579
21580
21581 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21582 PyObject *resultobj = 0;
21583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21584 int arg2 ;
21585 void *argp1 = 0 ;
21586 int res1 = 0 ;
21587 int val2 ;
21588 int ecode2 = 0 ;
21589 PyObject *swig_obj[2] ;
21590
21591 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21593 if (!SWIG_IsOK(res1)) {
21594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21595 }
21596 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21597 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21598 if (!SWIG_IsOK(ecode2)) {
21599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21600 }
21601 arg2 = static_cast< int >(val2);
21602 if (arg1) (arg1)->m_linesPerAction = arg2;
21603
21604 resultobj = SWIG_Py_Void();
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21612 PyObject *resultobj = 0;
21613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21614 int result;
21615 void *argp1 = 0 ;
21616 int res1 = 0 ;
21617 PyObject *swig_obj[1] ;
21618
21619 if (!args) SWIG_fail;
21620 swig_obj[0] = args;
21621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21622 if (!SWIG_IsOK(res1)) {
21623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21624 }
21625 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21626 result = (int) ((arg1)->m_linesPerAction);
21627 resultobj = SWIG_From_int(static_cast< int >(result));
21628 return resultobj;
21629 fail:
21630 return NULL;
21631 }
21632
21633
21634 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21635 PyObject *obj;
21636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21637 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21638 return SWIG_Py_Void();
21639 }
21640
21641 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21642 return SWIG_Python_InitShadowInstance(args);
21643 }
21644
21645 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21646 PyObject *resultobj = 0;
21647 int arg1 = (int) 0 ;
21648 int arg2 = (int) 0 ;
21649 wxSetCursorEvent *result = 0 ;
21650 int val1 ;
21651 int ecode1 = 0 ;
21652 int val2 ;
21653 int ecode2 = 0 ;
21654 PyObject * obj0 = 0 ;
21655 PyObject * obj1 = 0 ;
21656 char * kwnames[] = {
21657 (char *) "x",(char *) "y", NULL
21658 };
21659
21660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21661 if (obj0) {
21662 ecode1 = SWIG_AsVal_int(obj0, &val1);
21663 if (!SWIG_IsOK(ecode1)) {
21664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21665 }
21666 arg1 = static_cast< int >(val1);
21667 }
21668 if (obj1) {
21669 ecode2 = SWIG_AsVal_int(obj1, &val2);
21670 if (!SWIG_IsOK(ecode2)) {
21671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21672 }
21673 arg2 = static_cast< int >(val2);
21674 }
21675 {
21676 PyThreadState* __tstate = wxPyBeginAllowThreads();
21677 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21678 wxPyEndAllowThreads(__tstate);
21679 if (PyErr_Occurred()) SWIG_fail;
21680 }
21681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21682 return resultobj;
21683 fail:
21684 return NULL;
21685 }
21686
21687
21688 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21689 PyObject *resultobj = 0;
21690 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21691 int result;
21692 void *argp1 = 0 ;
21693 int res1 = 0 ;
21694 PyObject *swig_obj[1] ;
21695
21696 if (!args) SWIG_fail;
21697 swig_obj[0] = args;
21698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21699 if (!SWIG_IsOK(res1)) {
21700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21701 }
21702 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21703 {
21704 PyThreadState* __tstate = wxPyBeginAllowThreads();
21705 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 resultobj = SWIG_From_int(static_cast< int >(result));
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21717 PyObject *resultobj = 0;
21718 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21719 int result;
21720 void *argp1 = 0 ;
21721 int res1 = 0 ;
21722 PyObject *swig_obj[1] ;
21723
21724 if (!args) SWIG_fail;
21725 swig_obj[0] = args;
21726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21727 if (!SWIG_IsOK(res1)) {
21728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21729 }
21730 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21731 {
21732 PyThreadState* __tstate = wxPyBeginAllowThreads();
21733 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21734 wxPyEndAllowThreads(__tstate);
21735 if (PyErr_Occurred()) SWIG_fail;
21736 }
21737 resultobj = SWIG_From_int(static_cast< int >(result));
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj = 0;
21746 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21747 wxCursor *arg2 = 0 ;
21748 void *argp1 = 0 ;
21749 int res1 = 0 ;
21750 void *argp2 = 0 ;
21751 int res2 = 0 ;
21752 PyObject * obj0 = 0 ;
21753 PyObject * obj1 = 0 ;
21754 char * kwnames[] = {
21755 (char *) "self",(char *) "cursor", NULL
21756 };
21757
21758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21760 if (!SWIG_IsOK(res1)) {
21761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21762 }
21763 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21764 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21765 if (!SWIG_IsOK(res2)) {
21766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21767 }
21768 if (!argp2) {
21769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21770 }
21771 arg2 = reinterpret_cast< wxCursor * >(argp2);
21772 {
21773 PyThreadState* __tstate = wxPyBeginAllowThreads();
21774 (arg1)->SetCursor((wxCursor const &)*arg2);
21775 wxPyEndAllowThreads(__tstate);
21776 if (PyErr_Occurred()) SWIG_fail;
21777 }
21778 resultobj = SWIG_Py_Void();
21779 return resultobj;
21780 fail:
21781 return NULL;
21782 }
21783
21784
21785 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21786 PyObject *resultobj = 0;
21787 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21788 wxCursor *result = 0 ;
21789 void *argp1 = 0 ;
21790 int res1 = 0 ;
21791 PyObject *swig_obj[1] ;
21792
21793 if (!args) SWIG_fail;
21794 swig_obj[0] = args;
21795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21796 if (!SWIG_IsOK(res1)) {
21797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21798 }
21799 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 {
21803 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21804 result = (wxCursor *) &_result_ref;
21805 }
21806 wxPyEndAllowThreads(__tstate);
21807 if (PyErr_Occurred()) SWIG_fail;
21808 }
21809 {
21810 wxCursor* resultptr = new wxCursor(*result);
21811 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21812 }
21813 return resultobj;
21814 fail:
21815 return NULL;
21816 }
21817
21818
21819 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21820 PyObject *resultobj = 0;
21821 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21822 bool result;
21823 void *argp1 = 0 ;
21824 int res1 = 0 ;
21825 PyObject *swig_obj[1] ;
21826
21827 if (!args) SWIG_fail;
21828 swig_obj[0] = args;
21829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21830 if (!SWIG_IsOK(res1)) {
21831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21832 }
21833 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21834 {
21835 PyThreadState* __tstate = wxPyBeginAllowThreads();
21836 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21837 wxPyEndAllowThreads(__tstate);
21838 if (PyErr_Occurred()) SWIG_fail;
21839 }
21840 {
21841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21842 }
21843 return resultobj;
21844 fail:
21845 return NULL;
21846 }
21847
21848
21849 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21850 PyObject *obj;
21851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21852 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21853 return SWIG_Py_Void();
21854 }
21855
21856 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21857 return SWIG_Python_InitShadowInstance(args);
21858 }
21859
21860 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21861 PyObject *resultobj = 0;
21862 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21863 wxKeyEvent *result = 0 ;
21864 int val1 ;
21865 int ecode1 = 0 ;
21866 PyObject * obj0 = 0 ;
21867 char * kwnames[] = {
21868 (char *) "eventType", NULL
21869 };
21870
21871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21872 if (obj0) {
21873 ecode1 = SWIG_AsVal_int(obj0, &val1);
21874 if (!SWIG_IsOK(ecode1)) {
21875 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21876 }
21877 arg1 = static_cast< wxEventType >(val1);
21878 }
21879 {
21880 PyThreadState* __tstate = wxPyBeginAllowThreads();
21881 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21882 wxPyEndAllowThreads(__tstate);
21883 if (PyErr_Occurred()) SWIG_fail;
21884 }
21885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21886 return resultobj;
21887 fail:
21888 return NULL;
21889 }
21890
21891
21892 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21893 PyObject *resultobj = 0;
21894 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21895 int result;
21896 void *argp1 = 0 ;
21897 int res1 = 0 ;
21898 PyObject *swig_obj[1] ;
21899
21900 if (!args) SWIG_fail;
21901 swig_obj[0] = args;
21902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21903 if (!SWIG_IsOK(res1)) {
21904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21905 }
21906 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21907 {
21908 PyThreadState* __tstate = wxPyBeginAllowThreads();
21909 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21910 wxPyEndAllowThreads(__tstate);
21911 if (PyErr_Occurred()) SWIG_fail;
21912 }
21913 resultobj = SWIG_From_int(static_cast< int >(result));
21914 return resultobj;
21915 fail:
21916 return NULL;
21917 }
21918
21919
21920 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21921 PyObject *resultobj = 0;
21922 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21923 bool result;
21924 void *argp1 = 0 ;
21925 int res1 = 0 ;
21926 PyObject *swig_obj[1] ;
21927
21928 if (!args) SWIG_fail;
21929 swig_obj[0] = args;
21930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21931 if (!SWIG_IsOK(res1)) {
21932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21933 }
21934 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21935 {
21936 PyThreadState* __tstate = wxPyBeginAllowThreads();
21937 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21938 wxPyEndAllowThreads(__tstate);
21939 if (PyErr_Occurred()) SWIG_fail;
21940 }
21941 {
21942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21943 }
21944 return resultobj;
21945 fail:
21946 return NULL;
21947 }
21948
21949
21950 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21951 PyObject *resultobj = 0;
21952 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21953 bool result;
21954 void *argp1 = 0 ;
21955 int res1 = 0 ;
21956 PyObject *swig_obj[1] ;
21957
21958 if (!args) SWIG_fail;
21959 swig_obj[0] = args;
21960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21961 if (!SWIG_IsOK(res1)) {
21962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21963 }
21964 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21965 {
21966 PyThreadState* __tstate = wxPyBeginAllowThreads();
21967 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21968 wxPyEndAllowThreads(__tstate);
21969 if (PyErr_Occurred()) SWIG_fail;
21970 }
21971 {
21972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21973 }
21974 return resultobj;
21975 fail:
21976 return NULL;
21977 }
21978
21979
21980 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21981 PyObject *resultobj = 0;
21982 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21983 bool result;
21984 void *argp1 = 0 ;
21985 int res1 = 0 ;
21986 PyObject *swig_obj[1] ;
21987
21988 if (!args) SWIG_fail;
21989 swig_obj[0] = args;
21990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21991 if (!SWIG_IsOK(res1)) {
21992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21993 }
21994 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 {
22002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22003 }
22004 return resultobj;
22005 fail:
22006 return NULL;
22007 }
22008
22009
22010 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22011 PyObject *resultobj = 0;
22012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22013 bool result;
22014 void *argp1 = 0 ;
22015 int res1 = 0 ;
22016 PyObject *swig_obj[1] ;
22017
22018 if (!args) SWIG_fail;
22019 swig_obj[0] = args;
22020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22021 if (!SWIG_IsOK(res1)) {
22022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22023 }
22024 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22025 {
22026 PyThreadState* __tstate = wxPyBeginAllowThreads();
22027 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22028 wxPyEndAllowThreads(__tstate);
22029 if (PyErr_Occurred()) SWIG_fail;
22030 }
22031 {
22032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22033 }
22034 return resultobj;
22035 fail:
22036 return NULL;
22037 }
22038
22039
22040 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22041 PyObject *resultobj = 0;
22042 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22043 bool result;
22044 void *argp1 = 0 ;
22045 int res1 = 0 ;
22046 PyObject *swig_obj[1] ;
22047
22048 if (!args) SWIG_fail;
22049 swig_obj[0] = args;
22050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22051 if (!SWIG_IsOK(res1)) {
22052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22053 }
22054 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22055 {
22056 PyThreadState* __tstate = wxPyBeginAllowThreads();
22057 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22058 wxPyEndAllowThreads(__tstate);
22059 if (PyErr_Occurred()) SWIG_fail;
22060 }
22061 {
22062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22063 }
22064 return resultobj;
22065 fail:
22066 return NULL;
22067 }
22068
22069
22070 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22071 PyObject *resultobj = 0;
22072 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22073 bool result;
22074 void *argp1 = 0 ;
22075 int res1 = 0 ;
22076 PyObject *swig_obj[1] ;
22077
22078 if (!args) SWIG_fail;
22079 swig_obj[0] = args;
22080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22081 if (!SWIG_IsOK(res1)) {
22082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22083 }
22084 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22085 {
22086 PyThreadState* __tstate = wxPyBeginAllowThreads();
22087 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22088 wxPyEndAllowThreads(__tstate);
22089 if (PyErr_Occurred()) SWIG_fail;
22090 }
22091 {
22092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22093 }
22094 return resultobj;
22095 fail:
22096 return NULL;
22097 }
22098
22099
22100 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22101 PyObject *resultobj = 0;
22102 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22103 int result;
22104 void *argp1 = 0 ;
22105 int res1 = 0 ;
22106 PyObject *swig_obj[1] ;
22107
22108 if (!args) SWIG_fail;
22109 swig_obj[0] = args;
22110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22111 if (!SWIG_IsOK(res1)) {
22112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22113 }
22114 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22115 {
22116 PyThreadState* __tstate = wxPyBeginAllowThreads();
22117 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22118 wxPyEndAllowThreads(__tstate);
22119 if (PyErr_Occurred()) SWIG_fail;
22120 }
22121 resultobj = SWIG_From_int(static_cast< int >(result));
22122 return resultobj;
22123 fail:
22124 return NULL;
22125 }
22126
22127
22128 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22129 PyObject *resultobj = 0;
22130 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22131 int result;
22132 void *argp1 = 0 ;
22133 int res1 = 0 ;
22134 PyObject *swig_obj[1] ;
22135
22136 if (!args) SWIG_fail;
22137 swig_obj[0] = args;
22138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22139 if (!SWIG_IsOK(res1)) {
22140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22141 }
22142 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22143 {
22144 PyThreadState* __tstate = wxPyBeginAllowThreads();
22145 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22146 wxPyEndAllowThreads(__tstate);
22147 if (PyErr_Occurred()) SWIG_fail;
22148 }
22149 resultobj = SWIG_From_int(static_cast< int >(result));
22150 return resultobj;
22151 fail:
22152 return NULL;
22153 }
22154
22155
22156 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22157 PyObject *resultobj = 0;
22158 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22159 int arg2 ;
22160 void *argp1 = 0 ;
22161 int res1 = 0 ;
22162 int val2 ;
22163 int ecode2 = 0 ;
22164 PyObject * obj0 = 0 ;
22165 PyObject * obj1 = 0 ;
22166 char * kwnames[] = {
22167 (char *) "self",(char *) "uniChar", NULL
22168 };
22169
22170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22172 if (!SWIG_IsOK(res1)) {
22173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22174 }
22175 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22176 ecode2 = SWIG_AsVal_int(obj1, &val2);
22177 if (!SWIG_IsOK(ecode2)) {
22178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22179 }
22180 arg2 = static_cast< int >(val2);
22181 {
22182 PyThreadState* __tstate = wxPyBeginAllowThreads();
22183 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22184 wxPyEndAllowThreads(__tstate);
22185 if (PyErr_Occurred()) SWIG_fail;
22186 }
22187 resultobj = SWIG_Py_Void();
22188 return resultobj;
22189 fail:
22190 return NULL;
22191 }
22192
22193
22194 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22195 PyObject *resultobj = 0;
22196 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22197 unsigned int result;
22198 void *argp1 = 0 ;
22199 int res1 = 0 ;
22200 PyObject *swig_obj[1] ;
22201
22202 if (!args) SWIG_fail;
22203 swig_obj[0] = args;
22204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22205 if (!SWIG_IsOK(res1)) {
22206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22207 }
22208 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22209 {
22210 PyThreadState* __tstate = wxPyBeginAllowThreads();
22211 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22216 return resultobj;
22217 fail:
22218 return NULL;
22219 }
22220
22221
22222 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22223 PyObject *resultobj = 0;
22224 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22225 unsigned int result;
22226 void *argp1 = 0 ;
22227 int res1 = 0 ;
22228 PyObject *swig_obj[1] ;
22229
22230 if (!args) SWIG_fail;
22231 swig_obj[0] = args;
22232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22233 if (!SWIG_IsOK(res1)) {
22234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22235 }
22236 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22240 wxPyEndAllowThreads(__tstate);
22241 if (PyErr_Occurred()) SWIG_fail;
22242 }
22243 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22244 return resultobj;
22245 fail:
22246 return NULL;
22247 }
22248
22249
22250 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22251 PyObject *resultobj = 0;
22252 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22253 wxPoint result;
22254 void *argp1 = 0 ;
22255 int res1 = 0 ;
22256 PyObject *swig_obj[1] ;
22257
22258 if (!args) SWIG_fail;
22259 swig_obj[0] = args;
22260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22261 if (!SWIG_IsOK(res1)) {
22262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22263 }
22264 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22265 {
22266 PyThreadState* __tstate = wxPyBeginAllowThreads();
22267 result = (arg1)->GetPosition();
22268 wxPyEndAllowThreads(__tstate);
22269 if (PyErr_Occurred()) SWIG_fail;
22270 }
22271 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22272 return resultobj;
22273 fail:
22274 return NULL;
22275 }
22276
22277
22278 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22279 PyObject *resultobj = 0;
22280 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22281 long *arg2 = (long *) 0 ;
22282 long *arg3 = (long *) 0 ;
22283 void *argp1 = 0 ;
22284 int res1 = 0 ;
22285 long temp2 ;
22286 int res2 = SWIG_TMPOBJ ;
22287 long temp3 ;
22288 int res3 = SWIG_TMPOBJ ;
22289 PyObject *swig_obj[1] ;
22290
22291 arg2 = &temp2;
22292 arg3 = &temp3;
22293 if (!args) SWIG_fail;
22294 swig_obj[0] = args;
22295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22296 if (!SWIG_IsOK(res1)) {
22297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22298 }
22299 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 (arg1)->GetPosition(arg2,arg3);
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 resultobj = SWIG_Py_Void();
22307 if (SWIG_IsTmpObj(res2)) {
22308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22309 } else {
22310 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22312 }
22313 if (SWIG_IsTmpObj(res3)) {
22314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22315 } else {
22316 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22318 }
22319 return resultobj;
22320 fail:
22321 return NULL;
22322 }
22323
22324
22325 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22326 PyObject *resultobj = 0;
22327 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22328 int result;
22329 void *argp1 = 0 ;
22330 int res1 = 0 ;
22331 PyObject *swig_obj[1] ;
22332
22333 if (!args) SWIG_fail;
22334 swig_obj[0] = args;
22335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22336 if (!SWIG_IsOK(res1)) {
22337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22338 }
22339 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22340 {
22341 PyThreadState* __tstate = wxPyBeginAllowThreads();
22342 result = (int)((wxKeyEvent const *)arg1)->GetX();
22343 wxPyEndAllowThreads(__tstate);
22344 if (PyErr_Occurred()) SWIG_fail;
22345 }
22346 resultobj = SWIG_From_int(static_cast< int >(result));
22347 return resultobj;
22348 fail:
22349 return NULL;
22350 }
22351
22352
22353 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22354 PyObject *resultobj = 0;
22355 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22356 int result;
22357 void *argp1 = 0 ;
22358 int res1 = 0 ;
22359 PyObject *swig_obj[1] ;
22360
22361 if (!args) SWIG_fail;
22362 swig_obj[0] = args;
22363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22364 if (!SWIG_IsOK(res1)) {
22365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22366 }
22367 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22368 {
22369 PyThreadState* __tstate = wxPyBeginAllowThreads();
22370 result = (int)((wxKeyEvent const *)arg1)->GetY();
22371 wxPyEndAllowThreads(__tstate);
22372 if (PyErr_Occurred()) SWIG_fail;
22373 }
22374 resultobj = SWIG_From_int(static_cast< int >(result));
22375 return resultobj;
22376 fail:
22377 return NULL;
22378 }
22379
22380
22381 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22382 PyObject *resultobj = 0;
22383 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22384 int arg2 ;
22385 void *argp1 = 0 ;
22386 int res1 = 0 ;
22387 int val2 ;
22388 int ecode2 = 0 ;
22389 PyObject *swig_obj[2] ;
22390
22391 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22393 if (!SWIG_IsOK(res1)) {
22394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22395 }
22396 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22397 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22398 if (!SWIG_IsOK(ecode2)) {
22399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22400 }
22401 arg2 = static_cast< int >(val2);
22402 if (arg1) (arg1)->m_x = arg2;
22403
22404 resultobj = SWIG_Py_Void();
22405 return resultobj;
22406 fail:
22407 return NULL;
22408 }
22409
22410
22411 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22412 PyObject *resultobj = 0;
22413 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22414 int result;
22415 void *argp1 = 0 ;
22416 int res1 = 0 ;
22417 PyObject *swig_obj[1] ;
22418
22419 if (!args) SWIG_fail;
22420 swig_obj[0] = args;
22421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22422 if (!SWIG_IsOK(res1)) {
22423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22424 }
22425 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22426 result = (int) ((arg1)->m_x);
22427 resultobj = SWIG_From_int(static_cast< int >(result));
22428 return resultobj;
22429 fail:
22430 return NULL;
22431 }
22432
22433
22434 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22435 PyObject *resultobj = 0;
22436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22437 int arg2 ;
22438 void *argp1 = 0 ;
22439 int res1 = 0 ;
22440 int val2 ;
22441 int ecode2 = 0 ;
22442 PyObject *swig_obj[2] ;
22443
22444 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22446 if (!SWIG_IsOK(res1)) {
22447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22448 }
22449 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22450 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22451 if (!SWIG_IsOK(ecode2)) {
22452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22453 }
22454 arg2 = static_cast< int >(val2);
22455 if (arg1) (arg1)->m_y = arg2;
22456
22457 resultobj = SWIG_Py_Void();
22458 return resultobj;
22459 fail:
22460 return NULL;
22461 }
22462
22463
22464 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22465 PyObject *resultobj = 0;
22466 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22467 int result;
22468 void *argp1 = 0 ;
22469 int res1 = 0 ;
22470 PyObject *swig_obj[1] ;
22471
22472 if (!args) SWIG_fail;
22473 swig_obj[0] = args;
22474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22475 if (!SWIG_IsOK(res1)) {
22476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22477 }
22478 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22479 result = (int) ((arg1)->m_y);
22480 resultobj = SWIG_From_int(static_cast< int >(result));
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22488 PyObject *resultobj = 0;
22489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22490 long arg2 ;
22491 void *argp1 = 0 ;
22492 int res1 = 0 ;
22493 long val2 ;
22494 int ecode2 = 0 ;
22495 PyObject *swig_obj[2] ;
22496
22497 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22499 if (!SWIG_IsOK(res1)) {
22500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22501 }
22502 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22503 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22504 if (!SWIG_IsOK(ecode2)) {
22505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22506 }
22507 arg2 = static_cast< long >(val2);
22508 if (arg1) (arg1)->m_keyCode = arg2;
22509
22510 resultobj = SWIG_Py_Void();
22511 return resultobj;
22512 fail:
22513 return NULL;
22514 }
22515
22516
22517 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22518 PyObject *resultobj = 0;
22519 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22520 long result;
22521 void *argp1 = 0 ;
22522 int res1 = 0 ;
22523 PyObject *swig_obj[1] ;
22524
22525 if (!args) SWIG_fail;
22526 swig_obj[0] = args;
22527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22528 if (!SWIG_IsOK(res1)) {
22529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22530 }
22531 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22532 result = (long) ((arg1)->m_keyCode);
22533 resultobj = SWIG_From_long(static_cast< long >(result));
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22541 PyObject *resultobj = 0;
22542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22543 bool arg2 ;
22544 void *argp1 = 0 ;
22545 int res1 = 0 ;
22546 bool val2 ;
22547 int ecode2 = 0 ;
22548 PyObject *swig_obj[2] ;
22549
22550 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22552 if (!SWIG_IsOK(res1)) {
22553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22554 }
22555 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22556 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22557 if (!SWIG_IsOK(ecode2)) {
22558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22559 }
22560 arg2 = static_cast< bool >(val2);
22561 if (arg1) (arg1)->m_controlDown = arg2;
22562
22563 resultobj = SWIG_Py_Void();
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22571 PyObject *resultobj = 0;
22572 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22573 bool result;
22574 void *argp1 = 0 ;
22575 int res1 = 0 ;
22576 PyObject *swig_obj[1] ;
22577
22578 if (!args) SWIG_fail;
22579 swig_obj[0] = args;
22580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22581 if (!SWIG_IsOK(res1)) {
22582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22583 }
22584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22585 result = (bool) ((arg1)->m_controlDown);
22586 {
22587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22588 }
22589 return resultobj;
22590 fail:
22591 return NULL;
22592 }
22593
22594
22595 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22596 PyObject *resultobj = 0;
22597 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22598 bool arg2 ;
22599 void *argp1 = 0 ;
22600 int res1 = 0 ;
22601 bool val2 ;
22602 int ecode2 = 0 ;
22603 PyObject *swig_obj[2] ;
22604
22605 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22607 if (!SWIG_IsOK(res1)) {
22608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22609 }
22610 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22611 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22612 if (!SWIG_IsOK(ecode2)) {
22613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22614 }
22615 arg2 = static_cast< bool >(val2);
22616 if (arg1) (arg1)->m_shiftDown = arg2;
22617
22618 resultobj = SWIG_Py_Void();
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22626 PyObject *resultobj = 0;
22627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22628 bool result;
22629 void *argp1 = 0 ;
22630 int res1 = 0 ;
22631 PyObject *swig_obj[1] ;
22632
22633 if (!args) SWIG_fail;
22634 swig_obj[0] = args;
22635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22638 }
22639 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22640 result = (bool) ((arg1)->m_shiftDown);
22641 {
22642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22643 }
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22651 PyObject *resultobj = 0;
22652 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22653 bool arg2 ;
22654 void *argp1 = 0 ;
22655 int res1 = 0 ;
22656 bool val2 ;
22657 int ecode2 = 0 ;
22658 PyObject *swig_obj[2] ;
22659
22660 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22662 if (!SWIG_IsOK(res1)) {
22663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22664 }
22665 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22666 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22667 if (!SWIG_IsOK(ecode2)) {
22668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22669 }
22670 arg2 = static_cast< bool >(val2);
22671 if (arg1) (arg1)->m_altDown = arg2;
22672
22673 resultobj = SWIG_Py_Void();
22674 return resultobj;
22675 fail:
22676 return NULL;
22677 }
22678
22679
22680 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22681 PyObject *resultobj = 0;
22682 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22683 bool result;
22684 void *argp1 = 0 ;
22685 int res1 = 0 ;
22686 PyObject *swig_obj[1] ;
22687
22688 if (!args) SWIG_fail;
22689 swig_obj[0] = args;
22690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22691 if (!SWIG_IsOK(res1)) {
22692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22693 }
22694 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22695 result = (bool) ((arg1)->m_altDown);
22696 {
22697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22698 }
22699 return resultobj;
22700 fail:
22701 return NULL;
22702 }
22703
22704
22705 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22706 PyObject *resultobj = 0;
22707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22708 bool arg2 ;
22709 void *argp1 = 0 ;
22710 int res1 = 0 ;
22711 bool val2 ;
22712 int ecode2 = 0 ;
22713 PyObject *swig_obj[2] ;
22714
22715 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22717 if (!SWIG_IsOK(res1)) {
22718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22719 }
22720 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22721 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22722 if (!SWIG_IsOK(ecode2)) {
22723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22724 }
22725 arg2 = static_cast< bool >(val2);
22726 if (arg1) (arg1)->m_metaDown = arg2;
22727
22728 resultobj = SWIG_Py_Void();
22729 return resultobj;
22730 fail:
22731 return NULL;
22732 }
22733
22734
22735 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22736 PyObject *resultobj = 0;
22737 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22738 bool result;
22739 void *argp1 = 0 ;
22740 int res1 = 0 ;
22741 PyObject *swig_obj[1] ;
22742
22743 if (!args) SWIG_fail;
22744 swig_obj[0] = args;
22745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22746 if (!SWIG_IsOK(res1)) {
22747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22748 }
22749 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22750 result = (bool) ((arg1)->m_metaDown);
22751 {
22752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22753 }
22754 return resultobj;
22755 fail:
22756 return NULL;
22757 }
22758
22759
22760 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22761 PyObject *resultobj = 0;
22762 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22763 bool arg2 ;
22764 void *argp1 = 0 ;
22765 int res1 = 0 ;
22766 bool val2 ;
22767 int ecode2 = 0 ;
22768 PyObject *swig_obj[2] ;
22769
22770 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22772 if (!SWIG_IsOK(res1)) {
22773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22774 }
22775 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22776 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22777 if (!SWIG_IsOK(ecode2)) {
22778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22779 }
22780 arg2 = static_cast< bool >(val2);
22781 if (arg1) (arg1)->m_scanCode = arg2;
22782
22783 resultobj = SWIG_Py_Void();
22784 return resultobj;
22785 fail:
22786 return NULL;
22787 }
22788
22789
22790 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 PyObject *resultobj = 0;
22792 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22793 bool result;
22794 void *argp1 = 0 ;
22795 int res1 = 0 ;
22796 PyObject *swig_obj[1] ;
22797
22798 if (!args) SWIG_fail;
22799 swig_obj[0] = args;
22800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22801 if (!SWIG_IsOK(res1)) {
22802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22803 }
22804 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22805 result = (bool) ((arg1)->m_scanCode);
22806 {
22807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22808 }
22809 return resultobj;
22810 fail:
22811 return NULL;
22812 }
22813
22814
22815 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22816 PyObject *resultobj = 0;
22817 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22818 unsigned int arg2 ;
22819 void *argp1 = 0 ;
22820 int res1 = 0 ;
22821 unsigned int val2 ;
22822 int ecode2 = 0 ;
22823 PyObject *swig_obj[2] ;
22824
22825 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22827 if (!SWIG_IsOK(res1)) {
22828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22829 }
22830 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22831 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22832 if (!SWIG_IsOK(ecode2)) {
22833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22834 }
22835 arg2 = static_cast< unsigned int >(val2);
22836 if (arg1) (arg1)->m_rawCode = arg2;
22837
22838 resultobj = SWIG_Py_Void();
22839 return resultobj;
22840 fail:
22841 return NULL;
22842 }
22843
22844
22845 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22846 PyObject *resultobj = 0;
22847 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22848 unsigned int result;
22849 void *argp1 = 0 ;
22850 int res1 = 0 ;
22851 PyObject *swig_obj[1] ;
22852
22853 if (!args) SWIG_fail;
22854 swig_obj[0] = args;
22855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22856 if (!SWIG_IsOK(res1)) {
22857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22858 }
22859 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22860 result = (unsigned int) ((arg1)->m_rawCode);
22861 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22869 PyObject *resultobj = 0;
22870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22871 unsigned int arg2 ;
22872 void *argp1 = 0 ;
22873 int res1 = 0 ;
22874 unsigned int val2 ;
22875 int ecode2 = 0 ;
22876 PyObject *swig_obj[2] ;
22877
22878 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22880 if (!SWIG_IsOK(res1)) {
22881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22882 }
22883 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22884 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22885 if (!SWIG_IsOK(ecode2)) {
22886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22887 }
22888 arg2 = static_cast< unsigned int >(val2);
22889 if (arg1) (arg1)->m_rawFlags = arg2;
22890
22891 resultobj = SWIG_Py_Void();
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22899 PyObject *resultobj = 0;
22900 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22901 unsigned int result;
22902 void *argp1 = 0 ;
22903 int res1 = 0 ;
22904 PyObject *swig_obj[1] ;
22905
22906 if (!args) SWIG_fail;
22907 swig_obj[0] = args;
22908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22909 if (!SWIG_IsOK(res1)) {
22910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22911 }
22912 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22913 result = (unsigned int) ((arg1)->m_rawFlags);
22914 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22915 return resultobj;
22916 fail:
22917 return NULL;
22918 }
22919
22920
22921 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22922 PyObject *obj;
22923 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22924 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22925 return SWIG_Py_Void();
22926 }
22927
22928 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22929 return SWIG_Python_InitShadowInstance(args);
22930 }
22931
22932 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22933 PyObject *resultobj = 0;
22934 wxSize const &arg1_defvalue = wxDefaultSize ;
22935 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22936 int arg2 = (int) 0 ;
22937 wxSizeEvent *result = 0 ;
22938 wxSize temp1 ;
22939 int val2 ;
22940 int ecode2 = 0 ;
22941 PyObject * obj0 = 0 ;
22942 PyObject * obj1 = 0 ;
22943 char * kwnames[] = {
22944 (char *) "sz",(char *) "winid", NULL
22945 };
22946
22947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22948 if (obj0) {
22949 {
22950 arg1 = &temp1;
22951 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22952 }
22953 }
22954 if (obj1) {
22955 ecode2 = SWIG_AsVal_int(obj1, &val2);
22956 if (!SWIG_IsOK(ecode2)) {
22957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22958 }
22959 arg2 = static_cast< int >(val2);
22960 }
22961 {
22962 PyThreadState* __tstate = wxPyBeginAllowThreads();
22963 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22964 wxPyEndAllowThreads(__tstate);
22965 if (PyErr_Occurred()) SWIG_fail;
22966 }
22967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22968 return resultobj;
22969 fail:
22970 return NULL;
22971 }
22972
22973
22974 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22975 PyObject *resultobj = 0;
22976 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22977 wxSize result;
22978 void *argp1 = 0 ;
22979 int res1 = 0 ;
22980 PyObject *swig_obj[1] ;
22981
22982 if (!args) SWIG_fail;
22983 swig_obj[0] = args;
22984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22987 }
22988 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22989 {
22990 PyThreadState* __tstate = wxPyBeginAllowThreads();
22991 result = ((wxSizeEvent const *)arg1)->GetSize();
22992 wxPyEndAllowThreads(__tstate);
22993 if (PyErr_Occurred()) SWIG_fail;
22994 }
22995 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22996 return resultobj;
22997 fail:
22998 return NULL;
22999 }
23000
23001
23002 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23003 PyObject *resultobj = 0;
23004 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23005 wxRect result;
23006 void *argp1 = 0 ;
23007 int res1 = 0 ;
23008 PyObject *swig_obj[1] ;
23009
23010 if (!args) SWIG_fail;
23011 swig_obj[0] = args;
23012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23013 if (!SWIG_IsOK(res1)) {
23014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23015 }
23016 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 result = ((wxSizeEvent const *)arg1)->GetRect();
23020 wxPyEndAllowThreads(__tstate);
23021 if (PyErr_Occurred()) SWIG_fail;
23022 }
23023 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23024 return resultobj;
23025 fail:
23026 return NULL;
23027 }
23028
23029
23030 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23031 PyObject *resultobj = 0;
23032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23033 wxRect arg2 ;
23034 void *argp1 = 0 ;
23035 int res1 = 0 ;
23036 void *argp2 ;
23037 int res2 = 0 ;
23038 PyObject * obj0 = 0 ;
23039 PyObject * obj1 = 0 ;
23040 char * kwnames[] = {
23041 (char *) "self",(char *) "rect", NULL
23042 };
23043
23044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23046 if (!SWIG_IsOK(res1)) {
23047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23048 }
23049 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23050 {
23051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23052 if (!SWIG_IsOK(res2)) {
23053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23054 }
23055 if (!argp2) {
23056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23057 } else {
23058 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23059 arg2 = *temp;
23060 if (SWIG_IsNewObj(res2)) delete temp;
23061 }
23062 }
23063 {
23064 PyThreadState* __tstate = wxPyBeginAllowThreads();
23065 (arg1)->SetRect(arg2);
23066 wxPyEndAllowThreads(__tstate);
23067 if (PyErr_Occurred()) SWIG_fail;
23068 }
23069 resultobj = SWIG_Py_Void();
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23077 PyObject *resultobj = 0;
23078 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23079 wxSize arg2 ;
23080 void *argp1 = 0 ;
23081 int res1 = 0 ;
23082 void *argp2 ;
23083 int res2 = 0 ;
23084 PyObject * obj0 = 0 ;
23085 PyObject * obj1 = 0 ;
23086 char * kwnames[] = {
23087 (char *) "self",(char *) "size", NULL
23088 };
23089
23090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23094 }
23095 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23096 {
23097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23098 if (!SWIG_IsOK(res2)) {
23099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23100 }
23101 if (!argp2) {
23102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23103 } else {
23104 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23105 arg2 = *temp;
23106 if (SWIG_IsNewObj(res2)) delete temp;
23107 }
23108 }
23109 {
23110 PyThreadState* __tstate = wxPyBeginAllowThreads();
23111 wxSizeEvent_SetSize(arg1,arg2);
23112 wxPyEndAllowThreads(__tstate);
23113 if (PyErr_Occurred()) SWIG_fail;
23114 }
23115 resultobj = SWIG_Py_Void();
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23123 PyObject *resultobj = 0;
23124 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23125 wxSize *arg2 = (wxSize *) 0 ;
23126 void *argp1 = 0 ;
23127 int res1 = 0 ;
23128 void *argp2 = 0 ;
23129 int res2 = 0 ;
23130 PyObject *swig_obj[2] ;
23131
23132 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23134 if (!SWIG_IsOK(res1)) {
23135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23136 }
23137 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23138 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23139 if (!SWIG_IsOK(res2)) {
23140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23141 }
23142 arg2 = reinterpret_cast< wxSize * >(argp2);
23143 if (arg1) (arg1)->m_size = *arg2;
23144
23145 resultobj = SWIG_Py_Void();
23146 return resultobj;
23147 fail:
23148 return NULL;
23149 }
23150
23151
23152 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23153 PyObject *resultobj = 0;
23154 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23155 wxSize *result = 0 ;
23156 void *argp1 = 0 ;
23157 int res1 = 0 ;
23158 PyObject *swig_obj[1] ;
23159
23160 if (!args) SWIG_fail;
23161 swig_obj[0] = args;
23162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23163 if (!SWIG_IsOK(res1)) {
23164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23165 }
23166 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23167 result = (wxSize *)& ((arg1)->m_size);
23168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23169 return resultobj;
23170 fail:
23171 return NULL;
23172 }
23173
23174
23175 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23176 PyObject *resultobj = 0;
23177 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23178 wxRect *arg2 = (wxRect *) 0 ;
23179 void *argp1 = 0 ;
23180 int res1 = 0 ;
23181 void *argp2 = 0 ;
23182 int res2 = 0 ;
23183 PyObject *swig_obj[2] ;
23184
23185 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23187 if (!SWIG_IsOK(res1)) {
23188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23189 }
23190 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23191 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23192 if (!SWIG_IsOK(res2)) {
23193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23194 }
23195 arg2 = reinterpret_cast< wxRect * >(argp2);
23196 if (arg1) (arg1)->m_rect = *arg2;
23197
23198 resultobj = SWIG_Py_Void();
23199 return resultobj;
23200 fail:
23201 return NULL;
23202 }
23203
23204
23205 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23206 PyObject *resultobj = 0;
23207 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23208 wxRect *result = 0 ;
23209 void *argp1 = 0 ;
23210 int res1 = 0 ;
23211 PyObject *swig_obj[1] ;
23212
23213 if (!args) SWIG_fail;
23214 swig_obj[0] = args;
23215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23216 if (!SWIG_IsOK(res1)) {
23217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23218 }
23219 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23220 result = (wxRect *)& ((arg1)->m_rect);
23221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23229 PyObject *obj;
23230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23231 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23232 return SWIG_Py_Void();
23233 }
23234
23235 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23236 return SWIG_Python_InitShadowInstance(args);
23237 }
23238
23239 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23240 PyObject *resultobj = 0;
23241 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23242 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23243 int arg2 = (int) 0 ;
23244 wxMoveEvent *result = 0 ;
23245 wxPoint temp1 ;
23246 int val2 ;
23247 int ecode2 = 0 ;
23248 PyObject * obj0 = 0 ;
23249 PyObject * obj1 = 0 ;
23250 char * kwnames[] = {
23251 (char *) "pos",(char *) "winid", NULL
23252 };
23253
23254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23255 if (obj0) {
23256 {
23257 arg1 = &temp1;
23258 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23259 }
23260 }
23261 if (obj1) {
23262 ecode2 = SWIG_AsVal_int(obj1, &val2);
23263 if (!SWIG_IsOK(ecode2)) {
23264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23265 }
23266 arg2 = static_cast< int >(val2);
23267 }
23268 {
23269 PyThreadState* __tstate = wxPyBeginAllowThreads();
23270 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23271 wxPyEndAllowThreads(__tstate);
23272 if (PyErr_Occurred()) SWIG_fail;
23273 }
23274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23275 return resultobj;
23276 fail:
23277 return NULL;
23278 }
23279
23280
23281 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23282 PyObject *resultobj = 0;
23283 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23284 wxPoint result;
23285 void *argp1 = 0 ;
23286 int res1 = 0 ;
23287 PyObject *swig_obj[1] ;
23288
23289 if (!args) SWIG_fail;
23290 swig_obj[0] = args;
23291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23292 if (!SWIG_IsOK(res1)) {
23293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23294 }
23295 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23296 {
23297 PyThreadState* __tstate = wxPyBeginAllowThreads();
23298 result = ((wxMoveEvent const *)arg1)->GetPosition();
23299 wxPyEndAllowThreads(__tstate);
23300 if (PyErr_Occurred()) SWIG_fail;
23301 }
23302 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23303 return resultobj;
23304 fail:
23305 return NULL;
23306 }
23307
23308
23309 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23310 PyObject *resultobj = 0;
23311 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23312 wxRect result;
23313 void *argp1 = 0 ;
23314 int res1 = 0 ;
23315 PyObject *swig_obj[1] ;
23316
23317 if (!args) SWIG_fail;
23318 swig_obj[0] = args;
23319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23320 if (!SWIG_IsOK(res1)) {
23321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23322 }
23323 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23324 {
23325 PyThreadState* __tstate = wxPyBeginAllowThreads();
23326 result = ((wxMoveEvent const *)arg1)->GetRect();
23327 wxPyEndAllowThreads(__tstate);
23328 if (PyErr_Occurred()) SWIG_fail;
23329 }
23330 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23331 return resultobj;
23332 fail:
23333 return NULL;
23334 }
23335
23336
23337 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23338 PyObject *resultobj = 0;
23339 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23340 wxRect *arg2 = 0 ;
23341 void *argp1 = 0 ;
23342 int res1 = 0 ;
23343 wxRect temp2 ;
23344 PyObject * obj0 = 0 ;
23345 PyObject * obj1 = 0 ;
23346 char * kwnames[] = {
23347 (char *) "self",(char *) "rect", NULL
23348 };
23349
23350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23352 if (!SWIG_IsOK(res1)) {
23353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23354 }
23355 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23356 {
23357 arg2 = &temp2;
23358 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23359 }
23360 {
23361 PyThreadState* __tstate = wxPyBeginAllowThreads();
23362 (arg1)->SetRect((wxRect const &)*arg2);
23363 wxPyEndAllowThreads(__tstate);
23364 if (PyErr_Occurred()) SWIG_fail;
23365 }
23366 resultobj = SWIG_Py_Void();
23367 return resultobj;
23368 fail:
23369 return NULL;
23370 }
23371
23372
23373 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23374 PyObject *resultobj = 0;
23375 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23376 wxPoint *arg2 = 0 ;
23377 void *argp1 = 0 ;
23378 int res1 = 0 ;
23379 wxPoint temp2 ;
23380 PyObject * obj0 = 0 ;
23381 PyObject * obj1 = 0 ;
23382 char * kwnames[] = {
23383 (char *) "self",(char *) "pos", NULL
23384 };
23385
23386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23388 if (!SWIG_IsOK(res1)) {
23389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23390 }
23391 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23392 {
23393 arg2 = &temp2;
23394 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23395 }
23396 {
23397 PyThreadState* __tstate = wxPyBeginAllowThreads();
23398 (arg1)->SetPosition((wxPoint const &)*arg2);
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 resultobj = SWIG_Py_Void();
23403 return resultobj;
23404 fail:
23405 return NULL;
23406 }
23407
23408
23409 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23410 PyObject *obj;
23411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23412 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23413 return SWIG_Py_Void();
23414 }
23415
23416 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23417 return SWIG_Python_InitShadowInstance(args);
23418 }
23419
23420 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23421 PyObject *resultobj = 0;
23422 int arg1 = (int) 0 ;
23423 wxPaintEvent *result = 0 ;
23424 int val1 ;
23425 int ecode1 = 0 ;
23426 PyObject * obj0 = 0 ;
23427 char * kwnames[] = {
23428 (char *) "Id", NULL
23429 };
23430
23431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23432 if (obj0) {
23433 ecode1 = SWIG_AsVal_int(obj0, &val1);
23434 if (!SWIG_IsOK(ecode1)) {
23435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23436 }
23437 arg1 = static_cast< int >(val1);
23438 }
23439 {
23440 PyThreadState* __tstate = wxPyBeginAllowThreads();
23441 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23453 PyObject *obj;
23454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23455 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23456 return SWIG_Py_Void();
23457 }
23458
23459 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23460 return SWIG_Python_InitShadowInstance(args);
23461 }
23462
23463 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23464 PyObject *resultobj = 0;
23465 int arg1 = (int) 0 ;
23466 wxNcPaintEvent *result = 0 ;
23467 int val1 ;
23468 int ecode1 = 0 ;
23469 PyObject * obj0 = 0 ;
23470 char * kwnames[] = {
23471 (char *) "winid", NULL
23472 };
23473
23474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23475 if (obj0) {
23476 ecode1 = SWIG_AsVal_int(obj0, &val1);
23477 if (!SWIG_IsOK(ecode1)) {
23478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23479 }
23480 arg1 = static_cast< int >(val1);
23481 }
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23489 return resultobj;
23490 fail:
23491 return NULL;
23492 }
23493
23494
23495 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23496 PyObject *obj;
23497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23498 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23499 return SWIG_Py_Void();
23500 }
23501
23502 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23503 return SWIG_Python_InitShadowInstance(args);
23504 }
23505
23506 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23507 PyObject *resultobj = 0;
23508 int arg1 = (int) 0 ;
23509 wxDC *arg2 = (wxDC *) NULL ;
23510 wxEraseEvent *result = 0 ;
23511 int val1 ;
23512 int ecode1 = 0 ;
23513 void *argp2 = 0 ;
23514 int res2 = 0 ;
23515 PyObject * obj0 = 0 ;
23516 PyObject * obj1 = 0 ;
23517 char * kwnames[] = {
23518 (char *) "Id",(char *) "dc", NULL
23519 };
23520
23521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23522 if (obj0) {
23523 ecode1 = SWIG_AsVal_int(obj0, &val1);
23524 if (!SWIG_IsOK(ecode1)) {
23525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23526 }
23527 arg1 = static_cast< int >(val1);
23528 }
23529 if (obj1) {
23530 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23531 if (!SWIG_IsOK(res2)) {
23532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23533 }
23534 arg2 = reinterpret_cast< wxDC * >(argp2);
23535 }
23536 {
23537 PyThreadState* __tstate = wxPyBeginAllowThreads();
23538 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23539 wxPyEndAllowThreads(__tstate);
23540 if (PyErr_Occurred()) SWIG_fail;
23541 }
23542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23543 return resultobj;
23544 fail:
23545 return NULL;
23546 }
23547
23548
23549 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23550 PyObject *resultobj = 0;
23551 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23552 wxDC *result = 0 ;
23553 void *argp1 = 0 ;
23554 int res1 = 0 ;
23555 PyObject *swig_obj[1] ;
23556
23557 if (!args) SWIG_fail;
23558 swig_obj[0] = args;
23559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23560 if (!SWIG_IsOK(res1)) {
23561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23562 }
23563 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23564 {
23565 PyThreadState* __tstate = wxPyBeginAllowThreads();
23566 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23567 wxPyEndAllowThreads(__tstate);
23568 if (PyErr_Occurred()) SWIG_fail;
23569 }
23570 {
23571 resultobj = wxPyMake_wxObject(result, (bool)0);
23572 }
23573 return resultobj;
23574 fail:
23575 return NULL;
23576 }
23577
23578
23579 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23580 PyObject *obj;
23581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23582 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23583 return SWIG_Py_Void();
23584 }
23585
23586 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23587 return SWIG_Python_InitShadowInstance(args);
23588 }
23589
23590 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23591 PyObject *resultobj = 0;
23592 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23593 int arg2 = (int) 0 ;
23594 wxFocusEvent *result = 0 ;
23595 int val1 ;
23596 int ecode1 = 0 ;
23597 int val2 ;
23598 int ecode2 = 0 ;
23599 PyObject * obj0 = 0 ;
23600 PyObject * obj1 = 0 ;
23601 char * kwnames[] = {
23602 (char *) "type",(char *) "winid", NULL
23603 };
23604
23605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23606 if (obj0) {
23607 ecode1 = SWIG_AsVal_int(obj0, &val1);
23608 if (!SWIG_IsOK(ecode1)) {
23609 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23610 }
23611 arg1 = static_cast< wxEventType >(val1);
23612 }
23613 if (obj1) {
23614 ecode2 = SWIG_AsVal_int(obj1, &val2);
23615 if (!SWIG_IsOK(ecode2)) {
23616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23617 }
23618 arg2 = static_cast< int >(val2);
23619 }
23620 {
23621 PyThreadState* __tstate = wxPyBeginAllowThreads();
23622 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23623 wxPyEndAllowThreads(__tstate);
23624 if (PyErr_Occurred()) SWIG_fail;
23625 }
23626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23627 return resultobj;
23628 fail:
23629 return NULL;
23630 }
23631
23632
23633 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23634 PyObject *resultobj = 0;
23635 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23636 wxWindow *result = 0 ;
23637 void *argp1 = 0 ;
23638 int res1 = 0 ;
23639 PyObject *swig_obj[1] ;
23640
23641 if (!args) SWIG_fail;
23642 swig_obj[0] = args;
23643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23644 if (!SWIG_IsOK(res1)) {
23645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23646 }
23647 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23648 {
23649 PyThreadState* __tstate = wxPyBeginAllowThreads();
23650 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23651 wxPyEndAllowThreads(__tstate);
23652 if (PyErr_Occurred()) SWIG_fail;
23653 }
23654 {
23655 resultobj = wxPyMake_wxObject(result, (bool)0);
23656 }
23657 return resultobj;
23658 fail:
23659 return NULL;
23660 }
23661
23662
23663 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23664 PyObject *resultobj = 0;
23665 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23666 wxWindow *arg2 = (wxWindow *) 0 ;
23667 void *argp1 = 0 ;
23668 int res1 = 0 ;
23669 void *argp2 = 0 ;
23670 int res2 = 0 ;
23671 PyObject * obj0 = 0 ;
23672 PyObject * obj1 = 0 ;
23673 char * kwnames[] = {
23674 (char *) "self",(char *) "win", NULL
23675 };
23676
23677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23679 if (!SWIG_IsOK(res1)) {
23680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23681 }
23682 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23684 if (!SWIG_IsOK(res2)) {
23685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23686 }
23687 arg2 = reinterpret_cast< wxWindow * >(argp2);
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 (arg1)->SetWindow(arg2);
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 resultobj = SWIG_Py_Void();
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23702 PyObject *obj;
23703 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23704 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23705 return SWIG_Py_Void();
23706 }
23707
23708 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23709 return SWIG_Python_InitShadowInstance(args);
23710 }
23711
23712 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23713 PyObject *resultobj = 0;
23714 wxWindow *arg1 = (wxWindow *) NULL ;
23715 wxChildFocusEvent *result = 0 ;
23716 void *argp1 = 0 ;
23717 int res1 = 0 ;
23718 PyObject * obj0 = 0 ;
23719 char * kwnames[] = {
23720 (char *) "win", NULL
23721 };
23722
23723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23724 if (obj0) {
23725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23726 if (!SWIG_IsOK(res1)) {
23727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23728 }
23729 arg1 = reinterpret_cast< wxWindow * >(argp1);
23730 }
23731 {
23732 PyThreadState* __tstate = wxPyBeginAllowThreads();
23733 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23734 wxPyEndAllowThreads(__tstate);
23735 if (PyErr_Occurred()) SWIG_fail;
23736 }
23737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23738 return resultobj;
23739 fail:
23740 return NULL;
23741 }
23742
23743
23744 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23745 PyObject *resultobj = 0;
23746 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23747 wxWindow *result = 0 ;
23748 void *argp1 = 0 ;
23749 int res1 = 0 ;
23750 PyObject *swig_obj[1] ;
23751
23752 if (!args) SWIG_fail;
23753 swig_obj[0] = args;
23754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23755 if (!SWIG_IsOK(res1)) {
23756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23757 }
23758 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23759 {
23760 PyThreadState* __tstate = wxPyBeginAllowThreads();
23761 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23762 wxPyEndAllowThreads(__tstate);
23763 if (PyErr_Occurred()) SWIG_fail;
23764 }
23765 {
23766 resultobj = wxPyMake_wxObject(result, (bool)0);
23767 }
23768 return resultobj;
23769 fail:
23770 return NULL;
23771 }
23772
23773
23774 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23775 PyObject *obj;
23776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23777 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23778 return SWIG_Py_Void();
23779 }
23780
23781 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23782 return SWIG_Python_InitShadowInstance(args);
23783 }
23784
23785 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23786 PyObject *resultobj = 0;
23787 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23788 bool arg2 = (bool) true ;
23789 int arg3 = (int) 0 ;
23790 wxActivateEvent *result = 0 ;
23791 int val1 ;
23792 int ecode1 = 0 ;
23793 bool val2 ;
23794 int ecode2 = 0 ;
23795 int val3 ;
23796 int ecode3 = 0 ;
23797 PyObject * obj0 = 0 ;
23798 PyObject * obj1 = 0 ;
23799 PyObject * obj2 = 0 ;
23800 char * kwnames[] = {
23801 (char *) "type",(char *) "active",(char *) "Id", NULL
23802 };
23803
23804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23805 if (obj0) {
23806 ecode1 = SWIG_AsVal_int(obj0, &val1);
23807 if (!SWIG_IsOK(ecode1)) {
23808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23809 }
23810 arg1 = static_cast< wxEventType >(val1);
23811 }
23812 if (obj1) {
23813 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23814 if (!SWIG_IsOK(ecode2)) {
23815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23816 }
23817 arg2 = static_cast< bool >(val2);
23818 }
23819 if (obj2) {
23820 ecode3 = SWIG_AsVal_int(obj2, &val3);
23821 if (!SWIG_IsOK(ecode3)) {
23822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23823 }
23824 arg3 = static_cast< int >(val3);
23825 }
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23842 bool result;
23843 void *argp1 = 0 ;
23844 int res1 = 0 ;
23845 PyObject *swig_obj[1] ;
23846
23847 if (!args) SWIG_fail;
23848 swig_obj[0] = args;
23849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23850 if (!SWIG_IsOK(res1)) {
23851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23852 }
23853 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 {
23861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23862 }
23863 return resultobj;
23864 fail:
23865 return NULL;
23866 }
23867
23868
23869 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23870 PyObject *obj;
23871 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23872 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23873 return SWIG_Py_Void();
23874 }
23875
23876 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23877 return SWIG_Python_InitShadowInstance(args);
23878 }
23879
23880 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23881 PyObject *resultobj = 0;
23882 int arg1 = (int) 0 ;
23883 wxInitDialogEvent *result = 0 ;
23884 int val1 ;
23885 int ecode1 = 0 ;
23886 PyObject * obj0 = 0 ;
23887 char * kwnames[] = {
23888 (char *) "Id", NULL
23889 };
23890
23891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23892 if (obj0) {
23893 ecode1 = SWIG_AsVal_int(obj0, &val1);
23894 if (!SWIG_IsOK(ecode1)) {
23895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23896 }
23897 arg1 = static_cast< int >(val1);
23898 }
23899 {
23900 PyThreadState* __tstate = wxPyBeginAllowThreads();
23901 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23902 wxPyEndAllowThreads(__tstate);
23903 if (PyErr_Occurred()) SWIG_fail;
23904 }
23905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23906 return resultobj;
23907 fail:
23908 return NULL;
23909 }
23910
23911
23912 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23913 PyObject *obj;
23914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23915 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23916 return SWIG_Py_Void();
23917 }
23918
23919 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23920 return SWIG_Python_InitShadowInstance(args);
23921 }
23922
23923 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23924 PyObject *resultobj = 0;
23925 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23926 int arg2 = (int) 0 ;
23927 wxMenu *arg3 = (wxMenu *) NULL ;
23928 wxMenuEvent *result = 0 ;
23929 int val1 ;
23930 int ecode1 = 0 ;
23931 int val2 ;
23932 int ecode2 = 0 ;
23933 void *argp3 = 0 ;
23934 int res3 = 0 ;
23935 PyObject * obj0 = 0 ;
23936 PyObject * obj1 = 0 ;
23937 PyObject * obj2 = 0 ;
23938 char * kwnames[] = {
23939 (char *) "type",(char *) "winid",(char *) "menu", NULL
23940 };
23941
23942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23943 if (obj0) {
23944 ecode1 = SWIG_AsVal_int(obj0, &val1);
23945 if (!SWIG_IsOK(ecode1)) {
23946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23947 }
23948 arg1 = static_cast< wxEventType >(val1);
23949 }
23950 if (obj1) {
23951 ecode2 = SWIG_AsVal_int(obj1, &val2);
23952 if (!SWIG_IsOK(ecode2)) {
23953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23954 }
23955 arg2 = static_cast< int >(val2);
23956 }
23957 if (obj2) {
23958 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23959 if (!SWIG_IsOK(res3)) {
23960 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23961 }
23962 arg3 = reinterpret_cast< wxMenu * >(argp3);
23963 }
23964 {
23965 PyThreadState* __tstate = wxPyBeginAllowThreads();
23966 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23967 wxPyEndAllowThreads(__tstate);
23968 if (PyErr_Occurred()) SWIG_fail;
23969 }
23970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23978 PyObject *resultobj = 0;
23979 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23980 int result;
23981 void *argp1 = 0 ;
23982 int res1 = 0 ;
23983 PyObject *swig_obj[1] ;
23984
23985 if (!args) SWIG_fail;
23986 swig_obj[0] = args;
23987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23988 if (!SWIG_IsOK(res1)) {
23989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23990 }
23991 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 resultobj = SWIG_From_int(static_cast< int >(result));
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24006 PyObject *resultobj = 0;
24007 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24008 bool result;
24009 void *argp1 = 0 ;
24010 int res1 = 0 ;
24011 PyObject *swig_obj[1] ;
24012
24013 if (!args) SWIG_fail;
24014 swig_obj[0] = args;
24015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24016 if (!SWIG_IsOK(res1)) {
24017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24018 }
24019 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 {
24027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24028 }
24029 return resultobj;
24030 fail:
24031 return NULL;
24032 }
24033
24034
24035 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24036 PyObject *resultobj = 0;
24037 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24038 wxMenu *result = 0 ;
24039 void *argp1 = 0 ;
24040 int res1 = 0 ;
24041 PyObject *swig_obj[1] ;
24042
24043 if (!args) SWIG_fail;
24044 swig_obj[0] = args;
24045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24046 if (!SWIG_IsOK(res1)) {
24047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24048 }
24049 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 {
24057 resultobj = wxPyMake_wxObject(result, (bool)0);
24058 }
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24066 PyObject *obj;
24067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24068 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24069 return SWIG_Py_Void();
24070 }
24071
24072 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24073 return SWIG_Python_InitShadowInstance(args);
24074 }
24075
24076 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj = 0;
24078 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24079 int arg2 = (int) 0 ;
24080 wxCloseEvent *result = 0 ;
24081 int val1 ;
24082 int ecode1 = 0 ;
24083 int val2 ;
24084 int ecode2 = 0 ;
24085 PyObject * obj0 = 0 ;
24086 PyObject * obj1 = 0 ;
24087 char * kwnames[] = {
24088 (char *) "type",(char *) "winid", NULL
24089 };
24090
24091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24092 if (obj0) {
24093 ecode1 = SWIG_AsVal_int(obj0, &val1);
24094 if (!SWIG_IsOK(ecode1)) {
24095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24096 }
24097 arg1 = static_cast< wxEventType >(val1);
24098 }
24099 if (obj1) {
24100 ecode2 = SWIG_AsVal_int(obj1, &val2);
24101 if (!SWIG_IsOK(ecode2)) {
24102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24103 }
24104 arg2 = static_cast< int >(val2);
24105 }
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24109 wxPyEndAllowThreads(__tstate);
24110 if (PyErr_Occurred()) SWIG_fail;
24111 }
24112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24120 PyObject *resultobj = 0;
24121 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24122 bool arg2 ;
24123 void *argp1 = 0 ;
24124 int res1 = 0 ;
24125 bool val2 ;
24126 int ecode2 = 0 ;
24127 PyObject * obj0 = 0 ;
24128 PyObject * obj1 = 0 ;
24129 char * kwnames[] = {
24130 (char *) "self",(char *) "logOff", NULL
24131 };
24132
24133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24135 if (!SWIG_IsOK(res1)) {
24136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24137 }
24138 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24139 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24140 if (!SWIG_IsOK(ecode2)) {
24141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24142 }
24143 arg2 = static_cast< bool >(val2);
24144 {
24145 PyThreadState* __tstate = wxPyBeginAllowThreads();
24146 (arg1)->SetLoggingOff(arg2);
24147 wxPyEndAllowThreads(__tstate);
24148 if (PyErr_Occurred()) SWIG_fail;
24149 }
24150 resultobj = SWIG_Py_Void();
24151 return resultobj;
24152 fail:
24153 return NULL;
24154 }
24155
24156
24157 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24158 PyObject *resultobj = 0;
24159 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24160 bool result;
24161 void *argp1 = 0 ;
24162 int res1 = 0 ;
24163 PyObject *swig_obj[1] ;
24164
24165 if (!args) SWIG_fail;
24166 swig_obj[0] = args;
24167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24168 if (!SWIG_IsOK(res1)) {
24169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24170 }
24171 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24175 wxPyEndAllowThreads(__tstate);
24176 if (PyErr_Occurred()) SWIG_fail;
24177 }
24178 {
24179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24180 }
24181 return resultobj;
24182 fail:
24183 return NULL;
24184 }
24185
24186
24187 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24188 PyObject *resultobj = 0;
24189 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24190 bool arg2 = (bool) true ;
24191 void *argp1 = 0 ;
24192 int res1 = 0 ;
24193 bool val2 ;
24194 int ecode2 = 0 ;
24195 PyObject * obj0 = 0 ;
24196 PyObject * obj1 = 0 ;
24197 char * kwnames[] = {
24198 (char *) "self",(char *) "veto", NULL
24199 };
24200
24201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24203 if (!SWIG_IsOK(res1)) {
24204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24205 }
24206 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24207 if (obj1) {
24208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24209 if (!SWIG_IsOK(ecode2)) {
24210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24211 }
24212 arg2 = static_cast< bool >(val2);
24213 }
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 (arg1)->Veto(arg2);
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 resultobj = SWIG_Py_Void();
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24228 PyObject *resultobj = 0;
24229 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24230 bool result;
24231 void *argp1 = 0 ;
24232 int res1 = 0 ;
24233 PyObject *swig_obj[1] ;
24234
24235 if (!args) SWIG_fail;
24236 swig_obj[0] = args;
24237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24238 if (!SWIG_IsOK(res1)) {
24239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24240 }
24241 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24245 wxPyEndAllowThreads(__tstate);
24246 if (PyErr_Occurred()) SWIG_fail;
24247 }
24248 {
24249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24250 }
24251 return resultobj;
24252 fail:
24253 return NULL;
24254 }
24255
24256
24257 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24258 PyObject *resultobj = 0;
24259 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24260 bool arg2 ;
24261 void *argp1 = 0 ;
24262 int res1 = 0 ;
24263 bool val2 ;
24264 int ecode2 = 0 ;
24265 PyObject * obj0 = 0 ;
24266 PyObject * obj1 = 0 ;
24267 char * kwnames[] = {
24268 (char *) "self",(char *) "canVeto", NULL
24269 };
24270
24271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24273 if (!SWIG_IsOK(res1)) {
24274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24275 }
24276 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24277 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24278 if (!SWIG_IsOK(ecode2)) {
24279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24280 }
24281 arg2 = static_cast< bool >(val2);
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 (arg1)->SetCanVeto(arg2);
24285 wxPyEndAllowThreads(__tstate);
24286 if (PyErr_Occurred()) SWIG_fail;
24287 }
24288 resultobj = SWIG_Py_Void();
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24296 PyObject *resultobj = 0;
24297 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24298 bool result;
24299 void *argp1 = 0 ;
24300 int res1 = 0 ;
24301 PyObject *swig_obj[1] ;
24302
24303 if (!args) SWIG_fail;
24304 swig_obj[0] = args;
24305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24306 if (!SWIG_IsOK(res1)) {
24307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24308 }
24309 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24310 {
24311 PyThreadState* __tstate = wxPyBeginAllowThreads();
24312 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24313 wxPyEndAllowThreads(__tstate);
24314 if (PyErr_Occurred()) SWIG_fail;
24315 }
24316 {
24317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24318 }
24319 return resultobj;
24320 fail:
24321 return NULL;
24322 }
24323
24324
24325 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24326 PyObject *obj;
24327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24328 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24329 return SWIG_Py_Void();
24330 }
24331
24332 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24333 return SWIG_Python_InitShadowInstance(args);
24334 }
24335
24336 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24337 PyObject *resultobj = 0;
24338 int arg1 = (int) 0 ;
24339 bool arg2 = (bool) false ;
24340 wxShowEvent *result = 0 ;
24341 int val1 ;
24342 int ecode1 = 0 ;
24343 bool val2 ;
24344 int ecode2 = 0 ;
24345 PyObject * obj0 = 0 ;
24346 PyObject * obj1 = 0 ;
24347 char * kwnames[] = {
24348 (char *) "winid",(char *) "show", NULL
24349 };
24350
24351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24352 if (obj0) {
24353 ecode1 = SWIG_AsVal_int(obj0, &val1);
24354 if (!SWIG_IsOK(ecode1)) {
24355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24356 }
24357 arg1 = static_cast< int >(val1);
24358 }
24359 if (obj1) {
24360 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24361 if (!SWIG_IsOK(ecode2)) {
24362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24363 }
24364 arg2 = static_cast< bool >(val2);
24365 }
24366 {
24367 PyThreadState* __tstate = wxPyBeginAllowThreads();
24368 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24369 wxPyEndAllowThreads(__tstate);
24370 if (PyErr_Occurred()) SWIG_fail;
24371 }
24372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24373 return resultobj;
24374 fail:
24375 return NULL;
24376 }
24377
24378
24379 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24380 PyObject *resultobj = 0;
24381 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24382 bool arg2 ;
24383 void *argp1 = 0 ;
24384 int res1 = 0 ;
24385 bool val2 ;
24386 int ecode2 = 0 ;
24387 PyObject * obj0 = 0 ;
24388 PyObject * obj1 = 0 ;
24389 char * kwnames[] = {
24390 (char *) "self",(char *) "show", NULL
24391 };
24392
24393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24395 if (!SWIG_IsOK(res1)) {
24396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24397 }
24398 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24399 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24400 if (!SWIG_IsOK(ecode2)) {
24401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24402 }
24403 arg2 = static_cast< bool >(val2);
24404 {
24405 PyThreadState* __tstate = wxPyBeginAllowThreads();
24406 (arg1)->SetShow(arg2);
24407 wxPyEndAllowThreads(__tstate);
24408 if (PyErr_Occurred()) SWIG_fail;
24409 }
24410 resultobj = SWIG_Py_Void();
24411 return resultobj;
24412 fail:
24413 return NULL;
24414 }
24415
24416
24417 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24418 PyObject *resultobj = 0;
24419 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24420 bool result;
24421 void *argp1 = 0 ;
24422 int res1 = 0 ;
24423 PyObject *swig_obj[1] ;
24424
24425 if (!args) SWIG_fail;
24426 swig_obj[0] = args;
24427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24428 if (!SWIG_IsOK(res1)) {
24429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24430 }
24431 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24432 {
24433 PyThreadState* __tstate = wxPyBeginAllowThreads();
24434 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24435 wxPyEndAllowThreads(__tstate);
24436 if (PyErr_Occurred()) SWIG_fail;
24437 }
24438 {
24439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24440 }
24441 return resultobj;
24442 fail:
24443 return NULL;
24444 }
24445
24446
24447 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24448 PyObject *obj;
24449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24450 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24451 return SWIG_Py_Void();
24452 }
24453
24454 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24455 return SWIG_Python_InitShadowInstance(args);
24456 }
24457
24458 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24459 PyObject *resultobj = 0;
24460 int arg1 = (int) 0 ;
24461 bool arg2 = (bool) true ;
24462 wxIconizeEvent *result = 0 ;
24463 int val1 ;
24464 int ecode1 = 0 ;
24465 bool val2 ;
24466 int ecode2 = 0 ;
24467 PyObject * obj0 = 0 ;
24468 PyObject * obj1 = 0 ;
24469 char * kwnames[] = {
24470 (char *) "id",(char *) "iconized", NULL
24471 };
24472
24473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24474 if (obj0) {
24475 ecode1 = SWIG_AsVal_int(obj0, &val1);
24476 if (!SWIG_IsOK(ecode1)) {
24477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24478 }
24479 arg1 = static_cast< int >(val1);
24480 }
24481 if (obj1) {
24482 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24483 if (!SWIG_IsOK(ecode2)) {
24484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24485 }
24486 arg2 = static_cast< bool >(val2);
24487 }
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24491 wxPyEndAllowThreads(__tstate);
24492 if (PyErr_Occurred()) SWIG_fail;
24493 }
24494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24495 return resultobj;
24496 fail:
24497 return NULL;
24498 }
24499
24500
24501 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24502 PyObject *resultobj = 0;
24503 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24504 bool result;
24505 void *argp1 = 0 ;
24506 int res1 = 0 ;
24507 PyObject *swig_obj[1] ;
24508
24509 if (!args) SWIG_fail;
24510 swig_obj[0] = args;
24511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24512 if (!SWIG_IsOK(res1)) {
24513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24514 }
24515 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24516 {
24517 PyThreadState* __tstate = wxPyBeginAllowThreads();
24518 result = (bool)(arg1)->Iconized();
24519 wxPyEndAllowThreads(__tstate);
24520 if (PyErr_Occurred()) SWIG_fail;
24521 }
24522 {
24523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24524 }
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *obj;
24533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24534 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24535 return SWIG_Py_Void();
24536 }
24537
24538 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24539 return SWIG_Python_InitShadowInstance(args);
24540 }
24541
24542 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24543 PyObject *resultobj = 0;
24544 int arg1 = (int) 0 ;
24545 wxMaximizeEvent *result = 0 ;
24546 int val1 ;
24547 int ecode1 = 0 ;
24548 PyObject * obj0 = 0 ;
24549 char * kwnames[] = {
24550 (char *) "id", NULL
24551 };
24552
24553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24554 if (obj0) {
24555 ecode1 = SWIG_AsVal_int(obj0, &val1);
24556 if (!SWIG_IsOK(ecode1)) {
24557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24558 }
24559 arg1 = static_cast< int >(val1);
24560 }
24561 {
24562 PyThreadState* __tstate = wxPyBeginAllowThreads();
24563 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24575 PyObject *obj;
24576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24577 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24578 return SWIG_Py_Void();
24579 }
24580
24581 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24582 return SWIG_Python_InitShadowInstance(args);
24583 }
24584
24585 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24586 PyObject *resultobj = 0;
24587 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24588 wxPoint result;
24589 void *argp1 = 0 ;
24590 int res1 = 0 ;
24591 PyObject *swig_obj[1] ;
24592
24593 if (!args) SWIG_fail;
24594 swig_obj[0] = args;
24595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24596 if (!SWIG_IsOK(res1)) {
24597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24598 }
24599 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24600 {
24601 PyThreadState* __tstate = wxPyBeginAllowThreads();
24602 result = (arg1)->GetPosition();
24603 wxPyEndAllowThreads(__tstate);
24604 if (PyErr_Occurred()) SWIG_fail;
24605 }
24606 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24607 return resultobj;
24608 fail:
24609 return NULL;
24610 }
24611
24612
24613 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24614 PyObject *resultobj = 0;
24615 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24616 int result;
24617 void *argp1 = 0 ;
24618 int res1 = 0 ;
24619 PyObject *swig_obj[1] ;
24620
24621 if (!args) SWIG_fail;
24622 swig_obj[0] = args;
24623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24624 if (!SWIG_IsOK(res1)) {
24625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24626 }
24627 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24628 {
24629 PyThreadState* __tstate = wxPyBeginAllowThreads();
24630 result = (int)(arg1)->GetNumberOfFiles();
24631 wxPyEndAllowThreads(__tstate);
24632 if (PyErr_Occurred()) SWIG_fail;
24633 }
24634 resultobj = SWIG_From_int(static_cast< int >(result));
24635 return resultobj;
24636 fail:
24637 return NULL;
24638 }
24639
24640
24641 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24642 PyObject *resultobj = 0;
24643 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24644 PyObject *result = 0 ;
24645 void *argp1 = 0 ;
24646 int res1 = 0 ;
24647 PyObject *swig_obj[1] ;
24648
24649 if (!args) SWIG_fail;
24650 swig_obj[0] = args;
24651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24652 if (!SWIG_IsOK(res1)) {
24653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24654 }
24655 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24656 {
24657 PyThreadState* __tstate = wxPyBeginAllowThreads();
24658 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24659 wxPyEndAllowThreads(__tstate);
24660 if (PyErr_Occurred()) SWIG_fail;
24661 }
24662 resultobj = result;
24663 return resultobj;
24664 fail:
24665 return NULL;
24666 }
24667
24668
24669 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24670 PyObject *obj;
24671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24672 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24673 return SWIG_Py_Void();
24674 }
24675
24676 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24677 PyObject *resultobj = 0;
24678 int arg1 = (int) 0 ;
24679 wxUpdateUIEvent *result = 0 ;
24680 int val1 ;
24681 int ecode1 = 0 ;
24682 PyObject * obj0 = 0 ;
24683 char * kwnames[] = {
24684 (char *) "commandId", NULL
24685 };
24686
24687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24688 if (obj0) {
24689 ecode1 = SWIG_AsVal_int(obj0, &val1);
24690 if (!SWIG_IsOK(ecode1)) {
24691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24692 }
24693 arg1 = static_cast< int >(val1);
24694 }
24695 {
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24698 wxPyEndAllowThreads(__tstate);
24699 if (PyErr_Occurred()) SWIG_fail;
24700 }
24701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24702 return resultobj;
24703 fail:
24704 return NULL;
24705 }
24706
24707
24708 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24709 PyObject *resultobj = 0;
24710 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24711 bool result;
24712 void *argp1 = 0 ;
24713 int res1 = 0 ;
24714 PyObject *swig_obj[1] ;
24715
24716 if (!args) SWIG_fail;
24717 swig_obj[0] = args;
24718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24719 if (!SWIG_IsOK(res1)) {
24720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24721 }
24722 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24723 {
24724 PyThreadState* __tstate = wxPyBeginAllowThreads();
24725 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24726 wxPyEndAllowThreads(__tstate);
24727 if (PyErr_Occurred()) SWIG_fail;
24728 }
24729 {
24730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24731 }
24732 return resultobj;
24733 fail:
24734 return NULL;
24735 }
24736
24737
24738 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24739 PyObject *resultobj = 0;
24740 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24741 bool result;
24742 void *argp1 = 0 ;
24743 int res1 = 0 ;
24744 PyObject *swig_obj[1] ;
24745
24746 if (!args) SWIG_fail;
24747 swig_obj[0] = args;
24748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24749 if (!SWIG_IsOK(res1)) {
24750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24751 }
24752 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24753 {
24754 PyThreadState* __tstate = wxPyBeginAllowThreads();
24755 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24756 wxPyEndAllowThreads(__tstate);
24757 if (PyErr_Occurred()) SWIG_fail;
24758 }
24759 {
24760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24761 }
24762 return resultobj;
24763 fail:
24764 return NULL;
24765 }
24766
24767
24768 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24769 PyObject *resultobj = 0;
24770 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24771 bool result;
24772 void *argp1 = 0 ;
24773 int res1 = 0 ;
24774 PyObject *swig_obj[1] ;
24775
24776 if (!args) SWIG_fail;
24777 swig_obj[0] = args;
24778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24779 if (!SWIG_IsOK(res1)) {
24780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24781 }
24782 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24783 {
24784 PyThreadState* __tstate = wxPyBeginAllowThreads();
24785 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24786 wxPyEndAllowThreads(__tstate);
24787 if (PyErr_Occurred()) SWIG_fail;
24788 }
24789 {
24790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24791 }
24792 return resultobj;
24793 fail:
24794 return NULL;
24795 }
24796
24797
24798 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24799 PyObject *resultobj = 0;
24800 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24801 wxString result;
24802 void *argp1 = 0 ;
24803 int res1 = 0 ;
24804 PyObject *swig_obj[1] ;
24805
24806 if (!args) SWIG_fail;
24807 swig_obj[0] = args;
24808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24809 if (!SWIG_IsOK(res1)) {
24810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24811 }
24812 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24813 {
24814 PyThreadState* __tstate = wxPyBeginAllowThreads();
24815 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24816 wxPyEndAllowThreads(__tstate);
24817 if (PyErr_Occurred()) SWIG_fail;
24818 }
24819 {
24820 #if wxUSE_UNICODE
24821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24822 #else
24823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24824 #endif
24825 }
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24833 PyObject *resultobj = 0;
24834 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24835 bool result;
24836 void *argp1 = 0 ;
24837 int res1 = 0 ;
24838 PyObject *swig_obj[1] ;
24839
24840 if (!args) SWIG_fail;
24841 swig_obj[0] = args;
24842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24843 if (!SWIG_IsOK(res1)) {
24844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24845 }
24846 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24847 {
24848 PyThreadState* __tstate = wxPyBeginAllowThreads();
24849 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24850 wxPyEndAllowThreads(__tstate);
24851 if (PyErr_Occurred()) SWIG_fail;
24852 }
24853 {
24854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24855 }
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24863 PyObject *resultobj = 0;
24864 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24865 bool result;
24866 void *argp1 = 0 ;
24867 int res1 = 0 ;
24868 PyObject *swig_obj[1] ;
24869
24870 if (!args) SWIG_fail;
24871 swig_obj[0] = args;
24872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24875 }
24876 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 {
24884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24885 }
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24893 PyObject *resultobj = 0;
24894 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24895 bool result;
24896 void *argp1 = 0 ;
24897 int res1 = 0 ;
24898 PyObject *swig_obj[1] ;
24899
24900 if (!args) SWIG_fail;
24901 swig_obj[0] = args;
24902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24903 if (!SWIG_IsOK(res1)) {
24904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24905 }
24906 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24907 {
24908 PyThreadState* __tstate = wxPyBeginAllowThreads();
24909 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 {
24914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24915 }
24916 return resultobj;
24917 fail:
24918 return NULL;
24919 }
24920
24921
24922 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24923 PyObject *resultobj = 0;
24924 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24925 bool result;
24926 void *argp1 = 0 ;
24927 int res1 = 0 ;
24928 PyObject *swig_obj[1] ;
24929
24930 if (!args) SWIG_fail;
24931 swig_obj[0] = args;
24932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24933 if (!SWIG_IsOK(res1)) {
24934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24935 }
24936 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24940 wxPyEndAllowThreads(__tstate);
24941 if (PyErr_Occurred()) SWIG_fail;
24942 }
24943 {
24944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24945 }
24946 return resultobj;
24947 fail:
24948 return NULL;
24949 }
24950
24951
24952 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24953 PyObject *resultobj = 0;
24954 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24955 bool arg2 ;
24956 void *argp1 = 0 ;
24957 int res1 = 0 ;
24958 bool val2 ;
24959 int ecode2 = 0 ;
24960 PyObject * obj0 = 0 ;
24961 PyObject * obj1 = 0 ;
24962 char * kwnames[] = {
24963 (char *) "self",(char *) "check", NULL
24964 };
24965
24966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24968 if (!SWIG_IsOK(res1)) {
24969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24970 }
24971 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24972 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24973 if (!SWIG_IsOK(ecode2)) {
24974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24975 }
24976 arg2 = static_cast< bool >(val2);
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 (arg1)->Check(arg2);
24980 wxPyEndAllowThreads(__tstate);
24981 if (PyErr_Occurred()) SWIG_fail;
24982 }
24983 resultobj = SWIG_Py_Void();
24984 return resultobj;
24985 fail:
24986 return NULL;
24987 }
24988
24989
24990 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24991 PyObject *resultobj = 0;
24992 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24993 bool arg2 ;
24994 void *argp1 = 0 ;
24995 int res1 = 0 ;
24996 bool val2 ;
24997 int ecode2 = 0 ;
24998 PyObject * obj0 = 0 ;
24999 PyObject * obj1 = 0 ;
25000 char * kwnames[] = {
25001 (char *) "self",(char *) "enable", NULL
25002 };
25003
25004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25006 if (!SWIG_IsOK(res1)) {
25007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25008 }
25009 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25010 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25011 if (!SWIG_IsOK(ecode2)) {
25012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25013 }
25014 arg2 = static_cast< bool >(val2);
25015 {
25016 PyThreadState* __tstate = wxPyBeginAllowThreads();
25017 (arg1)->Enable(arg2);
25018 wxPyEndAllowThreads(__tstate);
25019 if (PyErr_Occurred()) SWIG_fail;
25020 }
25021 resultobj = SWIG_Py_Void();
25022 return resultobj;
25023 fail:
25024 return NULL;
25025 }
25026
25027
25028 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25029 PyObject *resultobj = 0;
25030 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25031 bool arg2 ;
25032 void *argp1 = 0 ;
25033 int res1 = 0 ;
25034 bool val2 ;
25035 int ecode2 = 0 ;
25036 PyObject * obj0 = 0 ;
25037 PyObject * obj1 = 0 ;
25038 char * kwnames[] = {
25039 (char *) "self",(char *) "show", NULL
25040 };
25041
25042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25044 if (!SWIG_IsOK(res1)) {
25045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25046 }
25047 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25048 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25049 if (!SWIG_IsOK(ecode2)) {
25050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25051 }
25052 arg2 = static_cast< bool >(val2);
25053 {
25054 PyThreadState* __tstate = wxPyBeginAllowThreads();
25055 (arg1)->Show(arg2);
25056 wxPyEndAllowThreads(__tstate);
25057 if (PyErr_Occurred()) SWIG_fail;
25058 }
25059 resultobj = SWIG_Py_Void();
25060 return resultobj;
25061 fail:
25062 return NULL;
25063 }
25064
25065
25066 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25067 PyObject *resultobj = 0;
25068 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25069 wxString *arg2 = 0 ;
25070 void *argp1 = 0 ;
25071 int res1 = 0 ;
25072 bool temp2 = false ;
25073 PyObject * obj0 = 0 ;
25074 PyObject * obj1 = 0 ;
25075 char * kwnames[] = {
25076 (char *) "self",(char *) "text", NULL
25077 };
25078
25079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25081 if (!SWIG_IsOK(res1)) {
25082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25083 }
25084 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25085 {
25086 arg2 = wxString_in_helper(obj1);
25087 if (arg2 == NULL) SWIG_fail;
25088 temp2 = true;
25089 }
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 (arg1)->SetText((wxString const &)*arg2);
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 resultobj = SWIG_Py_Void();
25097 {
25098 if (temp2)
25099 delete arg2;
25100 }
25101 return resultobj;
25102 fail:
25103 {
25104 if (temp2)
25105 delete arg2;
25106 }
25107 return NULL;
25108 }
25109
25110
25111 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25112 PyObject *resultobj = 0;
25113 long arg1 ;
25114 long val1 ;
25115 int ecode1 = 0 ;
25116 PyObject * obj0 = 0 ;
25117 char * kwnames[] = {
25118 (char *) "updateInterval", NULL
25119 };
25120
25121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25122 ecode1 = SWIG_AsVal_long(obj0, &val1);
25123 if (!SWIG_IsOK(ecode1)) {
25124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25125 }
25126 arg1 = static_cast< long >(val1);
25127 {
25128 PyThreadState* __tstate = wxPyBeginAllowThreads();
25129 wxUpdateUIEvent::SetUpdateInterval(arg1);
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 resultobj = SWIG_Py_Void();
25134 return resultobj;
25135 fail:
25136 return NULL;
25137 }
25138
25139
25140 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25141 PyObject *resultobj = 0;
25142 long result;
25143
25144 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25148 wxPyEndAllowThreads(__tstate);
25149 if (PyErr_Occurred()) SWIG_fail;
25150 }
25151 resultobj = SWIG_From_long(static_cast< long >(result));
25152 return resultobj;
25153 fail:
25154 return NULL;
25155 }
25156
25157
25158 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25159 PyObject *resultobj = 0;
25160 wxWindow *arg1 = (wxWindow *) 0 ;
25161 bool result;
25162 void *argp1 = 0 ;
25163 int res1 = 0 ;
25164 PyObject * obj0 = 0 ;
25165 char * kwnames[] = {
25166 (char *) "win", NULL
25167 };
25168
25169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25171 if (!SWIG_IsOK(res1)) {
25172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25173 }
25174 arg1 = reinterpret_cast< wxWindow * >(argp1);
25175 {
25176 PyThreadState* __tstate = wxPyBeginAllowThreads();
25177 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25178 wxPyEndAllowThreads(__tstate);
25179 if (PyErr_Occurred()) SWIG_fail;
25180 }
25181 {
25182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25183 }
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25191 PyObject *resultobj = 0;
25192
25193 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25194 {
25195 PyThreadState* __tstate = wxPyBeginAllowThreads();
25196 wxUpdateUIEvent::ResetUpdateTime();
25197 wxPyEndAllowThreads(__tstate);
25198 if (PyErr_Occurred()) SWIG_fail;
25199 }
25200 resultobj = SWIG_Py_Void();
25201 return resultobj;
25202 fail:
25203 return NULL;
25204 }
25205
25206
25207 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25208 PyObject *resultobj = 0;
25209 wxUpdateUIMode arg1 ;
25210 int val1 ;
25211 int ecode1 = 0 ;
25212 PyObject * obj0 = 0 ;
25213 char * kwnames[] = {
25214 (char *) "mode", NULL
25215 };
25216
25217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25218 ecode1 = SWIG_AsVal_int(obj0, &val1);
25219 if (!SWIG_IsOK(ecode1)) {
25220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25221 }
25222 arg1 = static_cast< wxUpdateUIMode >(val1);
25223 {
25224 PyThreadState* __tstate = wxPyBeginAllowThreads();
25225 wxUpdateUIEvent::SetMode(arg1);
25226 wxPyEndAllowThreads(__tstate);
25227 if (PyErr_Occurred()) SWIG_fail;
25228 }
25229 resultobj = SWIG_Py_Void();
25230 return resultobj;
25231 fail:
25232 return NULL;
25233 }
25234
25235
25236 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25237 PyObject *resultobj = 0;
25238 wxUpdateUIMode result;
25239
25240 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25244 wxPyEndAllowThreads(__tstate);
25245 if (PyErr_Occurred()) SWIG_fail;
25246 }
25247 resultobj = SWIG_From_int(static_cast< int >(result));
25248 return resultobj;
25249 fail:
25250 return NULL;
25251 }
25252
25253
25254 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25255 PyObject *obj;
25256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25257 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25258 return SWIG_Py_Void();
25259 }
25260
25261 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25262 return SWIG_Python_InitShadowInstance(args);
25263 }
25264
25265 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25266 PyObject *resultobj = 0;
25267 wxSysColourChangedEvent *result = 0 ;
25268
25269 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25270 {
25271 PyThreadState* __tstate = wxPyBeginAllowThreads();
25272 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25273 wxPyEndAllowThreads(__tstate);
25274 if (PyErr_Occurred()) SWIG_fail;
25275 }
25276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25277 return resultobj;
25278 fail:
25279 return NULL;
25280 }
25281
25282
25283 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25284 PyObject *obj;
25285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25286 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25287 return SWIG_Py_Void();
25288 }
25289
25290 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25291 return SWIG_Python_InitShadowInstance(args);
25292 }
25293
25294 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25295 PyObject *resultobj = 0;
25296 int arg1 = (int) 0 ;
25297 wxWindow *arg2 = (wxWindow *) NULL ;
25298 wxMouseCaptureChangedEvent *result = 0 ;
25299 int val1 ;
25300 int ecode1 = 0 ;
25301 void *argp2 = 0 ;
25302 int res2 = 0 ;
25303 PyObject * obj0 = 0 ;
25304 PyObject * obj1 = 0 ;
25305 char * kwnames[] = {
25306 (char *) "winid",(char *) "gainedCapture", NULL
25307 };
25308
25309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25310 if (obj0) {
25311 ecode1 = SWIG_AsVal_int(obj0, &val1);
25312 if (!SWIG_IsOK(ecode1)) {
25313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25314 }
25315 arg1 = static_cast< int >(val1);
25316 }
25317 if (obj1) {
25318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25319 if (!SWIG_IsOK(res2)) {
25320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25321 }
25322 arg2 = reinterpret_cast< wxWindow * >(argp2);
25323 }
25324 {
25325 PyThreadState* __tstate = wxPyBeginAllowThreads();
25326 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25327 wxPyEndAllowThreads(__tstate);
25328 if (PyErr_Occurred()) SWIG_fail;
25329 }
25330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25331 return resultobj;
25332 fail:
25333 return NULL;
25334 }
25335
25336
25337 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25338 PyObject *resultobj = 0;
25339 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25340 wxWindow *result = 0 ;
25341 void *argp1 = 0 ;
25342 int res1 = 0 ;
25343 PyObject *swig_obj[1] ;
25344
25345 if (!args) SWIG_fail;
25346 swig_obj[0] = args;
25347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25348 if (!SWIG_IsOK(res1)) {
25349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25350 }
25351 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25352 {
25353 PyThreadState* __tstate = wxPyBeginAllowThreads();
25354 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25355 wxPyEndAllowThreads(__tstate);
25356 if (PyErr_Occurred()) SWIG_fail;
25357 }
25358 {
25359 resultobj = wxPyMake_wxObject(result, (bool)0);
25360 }
25361 return resultobj;
25362 fail:
25363 return NULL;
25364 }
25365
25366
25367 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25368 PyObject *obj;
25369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25370 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25371 return SWIG_Py_Void();
25372 }
25373
25374 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25375 return SWIG_Python_InitShadowInstance(args);
25376 }
25377
25378 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25379 PyObject *resultobj = 0;
25380 wxDisplayChangedEvent *result = 0 ;
25381
25382 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25390 return resultobj;
25391 fail:
25392 return NULL;
25393 }
25394
25395
25396 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25397 PyObject *obj;
25398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25399 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25400 return SWIG_Py_Void();
25401 }
25402
25403 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25404 return SWIG_Python_InitShadowInstance(args);
25405 }
25406
25407 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25408 PyObject *resultobj = 0;
25409 int arg1 = (int) 0 ;
25410 wxPaletteChangedEvent *result = 0 ;
25411 int val1 ;
25412 int ecode1 = 0 ;
25413 PyObject * obj0 = 0 ;
25414 char * kwnames[] = {
25415 (char *) "id", NULL
25416 };
25417
25418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25419 if (obj0) {
25420 ecode1 = SWIG_AsVal_int(obj0, &val1);
25421 if (!SWIG_IsOK(ecode1)) {
25422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25423 }
25424 arg1 = static_cast< int >(val1);
25425 }
25426 {
25427 PyThreadState* __tstate = wxPyBeginAllowThreads();
25428 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25429 wxPyEndAllowThreads(__tstate);
25430 if (PyErr_Occurred()) SWIG_fail;
25431 }
25432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25433 return resultobj;
25434 fail:
25435 return NULL;
25436 }
25437
25438
25439 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25440 PyObject *resultobj = 0;
25441 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25442 wxWindow *arg2 = (wxWindow *) 0 ;
25443 void *argp1 = 0 ;
25444 int res1 = 0 ;
25445 void *argp2 = 0 ;
25446 int res2 = 0 ;
25447 PyObject * obj0 = 0 ;
25448 PyObject * obj1 = 0 ;
25449 char * kwnames[] = {
25450 (char *) "self",(char *) "win", NULL
25451 };
25452
25453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25455 if (!SWIG_IsOK(res1)) {
25456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25457 }
25458 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25459 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25460 if (!SWIG_IsOK(res2)) {
25461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25462 }
25463 arg2 = reinterpret_cast< wxWindow * >(argp2);
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 (arg1)->SetChangedWindow(arg2);
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 resultobj = SWIG_Py_Void();
25471 return resultobj;
25472 fail:
25473 return NULL;
25474 }
25475
25476
25477 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25478 PyObject *resultobj = 0;
25479 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25480 wxWindow *result = 0 ;
25481 void *argp1 = 0 ;
25482 int res1 = 0 ;
25483 PyObject *swig_obj[1] ;
25484
25485 if (!args) SWIG_fail;
25486 swig_obj[0] = args;
25487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25488 if (!SWIG_IsOK(res1)) {
25489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25490 }
25491 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25492 {
25493 PyThreadState* __tstate = wxPyBeginAllowThreads();
25494 result = (wxWindow *)(arg1)->GetChangedWindow();
25495 wxPyEndAllowThreads(__tstate);
25496 if (PyErr_Occurred()) SWIG_fail;
25497 }
25498 {
25499 resultobj = wxPyMake_wxObject(result, (bool)0);
25500 }
25501 return resultobj;
25502 fail:
25503 return NULL;
25504 }
25505
25506
25507 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25508 PyObject *obj;
25509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25510 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25511 return SWIG_Py_Void();
25512 }
25513
25514 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25515 return SWIG_Python_InitShadowInstance(args);
25516 }
25517
25518 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25519 PyObject *resultobj = 0;
25520 int arg1 = (int) 0 ;
25521 wxQueryNewPaletteEvent *result = 0 ;
25522 int val1 ;
25523 int ecode1 = 0 ;
25524 PyObject * obj0 = 0 ;
25525 char * kwnames[] = {
25526 (char *) "winid", NULL
25527 };
25528
25529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25530 if (obj0) {
25531 ecode1 = SWIG_AsVal_int(obj0, &val1);
25532 if (!SWIG_IsOK(ecode1)) {
25533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25534 }
25535 arg1 = static_cast< int >(val1);
25536 }
25537 {
25538 PyThreadState* __tstate = wxPyBeginAllowThreads();
25539 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25540 wxPyEndAllowThreads(__tstate);
25541 if (PyErr_Occurred()) SWIG_fail;
25542 }
25543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25544 return resultobj;
25545 fail:
25546 return NULL;
25547 }
25548
25549
25550 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25551 PyObject *resultobj = 0;
25552 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25553 bool arg2 ;
25554 void *argp1 = 0 ;
25555 int res1 = 0 ;
25556 bool val2 ;
25557 int ecode2 = 0 ;
25558 PyObject * obj0 = 0 ;
25559 PyObject * obj1 = 0 ;
25560 char * kwnames[] = {
25561 (char *) "self",(char *) "realized", NULL
25562 };
25563
25564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25566 if (!SWIG_IsOK(res1)) {
25567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25568 }
25569 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25570 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25571 if (!SWIG_IsOK(ecode2)) {
25572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25573 }
25574 arg2 = static_cast< bool >(val2);
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 (arg1)->SetPaletteRealized(arg2);
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 resultobj = SWIG_Py_Void();
25582 return resultobj;
25583 fail:
25584 return NULL;
25585 }
25586
25587
25588 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25589 PyObject *resultobj = 0;
25590 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25591 bool result;
25592 void *argp1 = 0 ;
25593 int res1 = 0 ;
25594 PyObject *swig_obj[1] ;
25595
25596 if (!args) SWIG_fail;
25597 swig_obj[0] = args;
25598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25599 if (!SWIG_IsOK(res1)) {
25600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25601 }
25602 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25603 {
25604 PyThreadState* __tstate = wxPyBeginAllowThreads();
25605 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25606 wxPyEndAllowThreads(__tstate);
25607 if (PyErr_Occurred()) SWIG_fail;
25608 }
25609 {
25610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25611 }
25612 return resultobj;
25613 fail:
25614 return NULL;
25615 }
25616
25617
25618 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25619 PyObject *obj;
25620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25621 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25622 return SWIG_Py_Void();
25623 }
25624
25625 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25626 return SWIG_Python_InitShadowInstance(args);
25627 }
25628
25629 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25630 PyObject *resultobj = 0;
25631 wxNavigationKeyEvent *result = 0 ;
25632
25633 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25641 return resultobj;
25642 fail:
25643 return NULL;
25644 }
25645
25646
25647 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25648 PyObject *resultobj = 0;
25649 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25650 bool result;
25651 void *argp1 = 0 ;
25652 int res1 = 0 ;
25653 PyObject *swig_obj[1] ;
25654
25655 if (!args) SWIG_fail;
25656 swig_obj[0] = args;
25657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25658 if (!SWIG_IsOK(res1)) {
25659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25660 }
25661 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 {
25669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25670 }
25671 return resultobj;
25672 fail:
25673 return NULL;
25674 }
25675
25676
25677 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25678 PyObject *resultobj = 0;
25679 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25680 bool arg2 ;
25681 void *argp1 = 0 ;
25682 int res1 = 0 ;
25683 bool val2 ;
25684 int ecode2 = 0 ;
25685 PyObject * obj0 = 0 ;
25686 PyObject * obj1 = 0 ;
25687 char * kwnames[] = {
25688 (char *) "self",(char *) "forward", NULL
25689 };
25690
25691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25693 if (!SWIG_IsOK(res1)) {
25694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25695 }
25696 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25697 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25698 if (!SWIG_IsOK(ecode2)) {
25699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25700 }
25701 arg2 = static_cast< bool >(val2);
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 (arg1)->SetDirection(arg2);
25705 wxPyEndAllowThreads(__tstate);
25706 if (PyErr_Occurred()) SWIG_fail;
25707 }
25708 resultobj = SWIG_Py_Void();
25709 return resultobj;
25710 fail:
25711 return NULL;
25712 }
25713
25714
25715 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25716 PyObject *resultobj = 0;
25717 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25718 bool result;
25719 void *argp1 = 0 ;
25720 int res1 = 0 ;
25721 PyObject *swig_obj[1] ;
25722
25723 if (!args) SWIG_fail;
25724 swig_obj[0] = args;
25725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25726 if (!SWIG_IsOK(res1)) {
25727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25728 }
25729 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25733 wxPyEndAllowThreads(__tstate);
25734 if (PyErr_Occurred()) SWIG_fail;
25735 }
25736 {
25737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25738 }
25739 return resultobj;
25740 fail:
25741 return NULL;
25742 }
25743
25744
25745 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25746 PyObject *resultobj = 0;
25747 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25748 bool arg2 ;
25749 void *argp1 = 0 ;
25750 int res1 = 0 ;
25751 bool val2 ;
25752 int ecode2 = 0 ;
25753 PyObject * obj0 = 0 ;
25754 PyObject * obj1 = 0 ;
25755 char * kwnames[] = {
25756 (char *) "self",(char *) "ischange", NULL
25757 };
25758
25759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25761 if (!SWIG_IsOK(res1)) {
25762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25763 }
25764 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25765 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25766 if (!SWIG_IsOK(ecode2)) {
25767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25768 }
25769 arg2 = static_cast< bool >(val2);
25770 {
25771 PyThreadState* __tstate = wxPyBeginAllowThreads();
25772 (arg1)->SetWindowChange(arg2);
25773 wxPyEndAllowThreads(__tstate);
25774 if (PyErr_Occurred()) SWIG_fail;
25775 }
25776 resultobj = SWIG_Py_Void();
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25784 PyObject *resultobj = 0;
25785 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25786 bool result;
25787 void *argp1 = 0 ;
25788 int res1 = 0 ;
25789 PyObject *swig_obj[1] ;
25790
25791 if (!args) SWIG_fail;
25792 swig_obj[0] = args;
25793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25794 if (!SWIG_IsOK(res1)) {
25795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25796 }
25797 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25798 {
25799 PyThreadState* __tstate = wxPyBeginAllowThreads();
25800 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25801 wxPyEndAllowThreads(__tstate);
25802 if (PyErr_Occurred()) SWIG_fail;
25803 }
25804 {
25805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25814 PyObject *resultobj = 0;
25815 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25816 bool arg2 ;
25817 void *argp1 = 0 ;
25818 int res1 = 0 ;
25819 bool val2 ;
25820 int ecode2 = 0 ;
25821 PyObject * obj0 = 0 ;
25822 PyObject * obj1 = 0 ;
25823 char * kwnames[] = {
25824 (char *) "self",(char *) "bIs", NULL
25825 };
25826
25827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25829 if (!SWIG_IsOK(res1)) {
25830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25831 }
25832 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25833 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25834 if (!SWIG_IsOK(ecode2)) {
25835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25836 }
25837 arg2 = static_cast< bool >(val2);
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 (arg1)->SetFromTab(arg2);
25841 wxPyEndAllowThreads(__tstate);
25842 if (PyErr_Occurred()) SWIG_fail;
25843 }
25844 resultobj = SWIG_Py_Void();
25845 return resultobj;
25846 fail:
25847 return NULL;
25848 }
25849
25850
25851 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25852 PyObject *resultobj = 0;
25853 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25854 long arg2 ;
25855 void *argp1 = 0 ;
25856 int res1 = 0 ;
25857 long val2 ;
25858 int ecode2 = 0 ;
25859 PyObject * obj0 = 0 ;
25860 PyObject * obj1 = 0 ;
25861 char * kwnames[] = {
25862 (char *) "self",(char *) "flags", NULL
25863 };
25864
25865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25867 if (!SWIG_IsOK(res1)) {
25868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25869 }
25870 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25871 ecode2 = SWIG_AsVal_long(obj1, &val2);
25872 if (!SWIG_IsOK(ecode2)) {
25873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25874 }
25875 arg2 = static_cast< long >(val2);
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 (arg1)->SetFlags(arg2);
25879 wxPyEndAllowThreads(__tstate);
25880 if (PyErr_Occurred()) SWIG_fail;
25881 }
25882 resultobj = SWIG_Py_Void();
25883 return resultobj;
25884 fail:
25885 return NULL;
25886 }
25887
25888
25889 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25890 PyObject *resultobj = 0;
25891 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25892 wxWindow *result = 0 ;
25893 void *argp1 = 0 ;
25894 int res1 = 0 ;
25895 PyObject *swig_obj[1] ;
25896
25897 if (!args) SWIG_fail;
25898 swig_obj[0] = args;
25899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25900 if (!SWIG_IsOK(res1)) {
25901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25902 }
25903 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25904 {
25905 PyThreadState* __tstate = wxPyBeginAllowThreads();
25906 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25907 wxPyEndAllowThreads(__tstate);
25908 if (PyErr_Occurred()) SWIG_fail;
25909 }
25910 {
25911 resultobj = wxPyMake_wxObject(result, (bool)0);
25912 }
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25920 PyObject *resultobj = 0;
25921 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25922 wxWindow *arg2 = (wxWindow *) 0 ;
25923 void *argp1 = 0 ;
25924 int res1 = 0 ;
25925 void *argp2 = 0 ;
25926 int res2 = 0 ;
25927 PyObject * obj0 = 0 ;
25928 PyObject * obj1 = 0 ;
25929 char * kwnames[] = {
25930 (char *) "self",(char *) "win", NULL
25931 };
25932
25933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25935 if (!SWIG_IsOK(res1)) {
25936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25937 }
25938 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25940 if (!SWIG_IsOK(res2)) {
25941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25942 }
25943 arg2 = reinterpret_cast< wxWindow * >(argp2);
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 (arg1)->SetCurrentFocus(arg2);
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_Py_Void();
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25958 PyObject *obj;
25959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25960 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25961 return SWIG_Py_Void();
25962 }
25963
25964 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25965 return SWIG_Python_InitShadowInstance(args);
25966 }
25967
25968 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25969 PyObject *resultobj = 0;
25970 wxWindow *arg1 = (wxWindow *) NULL ;
25971 wxWindowCreateEvent *result = 0 ;
25972 void *argp1 = 0 ;
25973 int res1 = 0 ;
25974 PyObject * obj0 = 0 ;
25975 char * kwnames[] = {
25976 (char *) "win", NULL
25977 };
25978
25979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25980 if (obj0) {
25981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25982 if (!SWIG_IsOK(res1)) {
25983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25984 }
25985 arg1 = reinterpret_cast< wxWindow * >(argp1);
25986 }
25987 {
25988 PyThreadState* __tstate = wxPyBeginAllowThreads();
25989 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25990 wxPyEndAllowThreads(__tstate);
25991 if (PyErr_Occurred()) SWIG_fail;
25992 }
25993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25994 return resultobj;
25995 fail:
25996 return NULL;
25997 }
25998
25999
26000 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26001 PyObject *resultobj = 0;
26002 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26003 wxWindow *result = 0 ;
26004 void *argp1 = 0 ;
26005 int res1 = 0 ;
26006 PyObject *swig_obj[1] ;
26007
26008 if (!args) SWIG_fail;
26009 swig_obj[0] = args;
26010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26011 if (!SWIG_IsOK(res1)) {
26012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26013 }
26014 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26015 {
26016 PyThreadState* __tstate = wxPyBeginAllowThreads();
26017 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26018 wxPyEndAllowThreads(__tstate);
26019 if (PyErr_Occurred()) SWIG_fail;
26020 }
26021 {
26022 resultobj = wxPyMake_wxObject(result, (bool)0);
26023 }
26024 return resultobj;
26025 fail:
26026 return NULL;
26027 }
26028
26029
26030 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26031 PyObject *obj;
26032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26033 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26034 return SWIG_Py_Void();
26035 }
26036
26037 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26038 return SWIG_Python_InitShadowInstance(args);
26039 }
26040
26041 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26042 PyObject *resultobj = 0;
26043 wxWindow *arg1 = (wxWindow *) NULL ;
26044 wxWindowDestroyEvent *result = 0 ;
26045 void *argp1 = 0 ;
26046 int res1 = 0 ;
26047 PyObject * obj0 = 0 ;
26048 char * kwnames[] = {
26049 (char *) "win", NULL
26050 };
26051
26052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26053 if (obj0) {
26054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26055 if (!SWIG_IsOK(res1)) {
26056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26057 }
26058 arg1 = reinterpret_cast< wxWindow * >(argp1);
26059 }
26060 {
26061 PyThreadState* __tstate = wxPyBeginAllowThreads();
26062 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26063 wxPyEndAllowThreads(__tstate);
26064 if (PyErr_Occurred()) SWIG_fail;
26065 }
26066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26067 return resultobj;
26068 fail:
26069 return NULL;
26070 }
26071
26072
26073 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26074 PyObject *resultobj = 0;
26075 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26076 wxWindow *result = 0 ;
26077 void *argp1 = 0 ;
26078 int res1 = 0 ;
26079 PyObject *swig_obj[1] ;
26080
26081 if (!args) SWIG_fail;
26082 swig_obj[0] = args;
26083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26084 if (!SWIG_IsOK(res1)) {
26085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26086 }
26087 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26088 {
26089 PyThreadState* __tstate = wxPyBeginAllowThreads();
26090 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26091 wxPyEndAllowThreads(__tstate);
26092 if (PyErr_Occurred()) SWIG_fail;
26093 }
26094 {
26095 resultobj = wxPyMake_wxObject(result, (bool)0);
26096 }
26097 return resultobj;
26098 fail:
26099 return NULL;
26100 }
26101
26102
26103 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26104 PyObject *obj;
26105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26106 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26107 return SWIG_Py_Void();
26108 }
26109
26110 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26111 return SWIG_Python_InitShadowInstance(args);
26112 }
26113
26114 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26115 PyObject *resultobj = 0;
26116 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26117 int arg2 = (int) 0 ;
26118 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26119 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26120 wxContextMenuEvent *result = 0 ;
26121 int val1 ;
26122 int ecode1 = 0 ;
26123 int val2 ;
26124 int ecode2 = 0 ;
26125 wxPoint temp3 ;
26126 PyObject * obj0 = 0 ;
26127 PyObject * obj1 = 0 ;
26128 PyObject * obj2 = 0 ;
26129 char * kwnames[] = {
26130 (char *) "type",(char *) "winid",(char *) "pt", NULL
26131 };
26132
26133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26134 if (obj0) {
26135 ecode1 = SWIG_AsVal_int(obj0, &val1);
26136 if (!SWIG_IsOK(ecode1)) {
26137 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26138 }
26139 arg1 = static_cast< wxEventType >(val1);
26140 }
26141 if (obj1) {
26142 ecode2 = SWIG_AsVal_int(obj1, &val2);
26143 if (!SWIG_IsOK(ecode2)) {
26144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26145 }
26146 arg2 = static_cast< int >(val2);
26147 }
26148 if (obj2) {
26149 {
26150 arg3 = &temp3;
26151 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26152 }
26153 }
26154 {
26155 PyThreadState* __tstate = wxPyBeginAllowThreads();
26156 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26157 wxPyEndAllowThreads(__tstate);
26158 if (PyErr_Occurred()) SWIG_fail;
26159 }
26160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26161 return resultobj;
26162 fail:
26163 return NULL;
26164 }
26165
26166
26167 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26168 PyObject *resultobj = 0;
26169 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26170 wxPoint *result = 0 ;
26171 void *argp1 = 0 ;
26172 int res1 = 0 ;
26173 PyObject *swig_obj[1] ;
26174
26175 if (!args) SWIG_fail;
26176 swig_obj[0] = args;
26177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26178 if (!SWIG_IsOK(res1)) {
26179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26180 }
26181 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 {
26185 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26186 result = (wxPoint *) &_result_ref;
26187 }
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26199 PyObject *resultobj = 0;
26200 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26201 wxPoint *arg2 = 0 ;
26202 void *argp1 = 0 ;
26203 int res1 = 0 ;
26204 wxPoint temp2 ;
26205 PyObject * obj0 = 0 ;
26206 PyObject * obj1 = 0 ;
26207 char * kwnames[] = {
26208 (char *) "self",(char *) "pos", NULL
26209 };
26210
26211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26213 if (!SWIG_IsOK(res1)) {
26214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26215 }
26216 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26217 {
26218 arg2 = &temp2;
26219 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26220 }
26221 {
26222 PyThreadState* __tstate = wxPyBeginAllowThreads();
26223 (arg1)->SetPosition((wxPoint const &)*arg2);
26224 wxPyEndAllowThreads(__tstate);
26225 if (PyErr_Occurred()) SWIG_fail;
26226 }
26227 resultobj = SWIG_Py_Void();
26228 return resultobj;
26229 fail:
26230 return NULL;
26231 }
26232
26233
26234 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26235 PyObject *obj;
26236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26237 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26238 return SWIG_Py_Void();
26239 }
26240
26241 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26242 return SWIG_Python_InitShadowInstance(args);
26243 }
26244
26245 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26246 PyObject *resultobj = 0;
26247 wxIdleEvent *result = 0 ;
26248
26249 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26250 {
26251 PyThreadState* __tstate = wxPyBeginAllowThreads();
26252 result = (wxIdleEvent *)new wxIdleEvent();
26253 wxPyEndAllowThreads(__tstate);
26254 if (PyErr_Occurred()) SWIG_fail;
26255 }
26256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26264 PyObject *resultobj = 0;
26265 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26266 bool arg2 = (bool) true ;
26267 void *argp1 = 0 ;
26268 int res1 = 0 ;
26269 bool val2 ;
26270 int ecode2 = 0 ;
26271 PyObject * obj0 = 0 ;
26272 PyObject * obj1 = 0 ;
26273 char * kwnames[] = {
26274 (char *) "self",(char *) "needMore", NULL
26275 };
26276
26277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26279 if (!SWIG_IsOK(res1)) {
26280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26281 }
26282 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26283 if (obj1) {
26284 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26285 if (!SWIG_IsOK(ecode2)) {
26286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26287 }
26288 arg2 = static_cast< bool >(val2);
26289 }
26290 {
26291 PyThreadState* __tstate = wxPyBeginAllowThreads();
26292 (arg1)->RequestMore(arg2);
26293 wxPyEndAllowThreads(__tstate);
26294 if (PyErr_Occurred()) SWIG_fail;
26295 }
26296 resultobj = SWIG_Py_Void();
26297 return resultobj;
26298 fail:
26299 return NULL;
26300 }
26301
26302
26303 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26304 PyObject *resultobj = 0;
26305 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26306 bool result;
26307 void *argp1 = 0 ;
26308 int res1 = 0 ;
26309 PyObject *swig_obj[1] ;
26310
26311 if (!args) SWIG_fail;
26312 swig_obj[0] = args;
26313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26314 if (!SWIG_IsOK(res1)) {
26315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26316 }
26317 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26318 {
26319 PyThreadState* __tstate = wxPyBeginAllowThreads();
26320 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26321 wxPyEndAllowThreads(__tstate);
26322 if (PyErr_Occurred()) SWIG_fail;
26323 }
26324 {
26325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26326 }
26327 return resultobj;
26328 fail:
26329 return NULL;
26330 }
26331
26332
26333 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26334 PyObject *resultobj = 0;
26335 wxIdleMode arg1 ;
26336 int val1 ;
26337 int ecode1 = 0 ;
26338 PyObject * obj0 = 0 ;
26339 char * kwnames[] = {
26340 (char *) "mode", NULL
26341 };
26342
26343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26344 ecode1 = SWIG_AsVal_int(obj0, &val1);
26345 if (!SWIG_IsOK(ecode1)) {
26346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26347 }
26348 arg1 = static_cast< wxIdleMode >(val1);
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 wxIdleEvent::SetMode(arg1);
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 resultobj = SWIG_Py_Void();
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26363 PyObject *resultobj = 0;
26364 wxIdleMode result;
26365
26366 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26367 {
26368 PyThreadState* __tstate = wxPyBeginAllowThreads();
26369 result = (wxIdleMode)wxIdleEvent::GetMode();
26370 wxPyEndAllowThreads(__tstate);
26371 if (PyErr_Occurred()) SWIG_fail;
26372 }
26373 resultobj = SWIG_From_int(static_cast< int >(result));
26374 return resultobj;
26375 fail:
26376 return NULL;
26377 }
26378
26379
26380 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26381 PyObject *resultobj = 0;
26382 wxWindow *arg1 = (wxWindow *) 0 ;
26383 bool result;
26384 void *argp1 = 0 ;
26385 int res1 = 0 ;
26386 PyObject * obj0 = 0 ;
26387 char * kwnames[] = {
26388 (char *) "win", NULL
26389 };
26390
26391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26393 if (!SWIG_IsOK(res1)) {
26394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26395 }
26396 arg1 = reinterpret_cast< wxWindow * >(argp1);
26397 {
26398 PyThreadState* __tstate = wxPyBeginAllowThreads();
26399 result = (bool)wxIdleEvent::CanSend(arg1);
26400 wxPyEndAllowThreads(__tstate);
26401 if (PyErr_Occurred()) SWIG_fail;
26402 }
26403 {
26404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26405 }
26406 return resultobj;
26407 fail:
26408 return NULL;
26409 }
26410
26411
26412 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26413 PyObject *obj;
26414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26415 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26416 return SWIG_Py_Void();
26417 }
26418
26419 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26420 return SWIG_Python_InitShadowInstance(args);
26421 }
26422
26423 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26424 PyObject *resultobj = 0;
26425 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26426 int arg2 = (int) 0 ;
26427 wxClipboardTextEvent *result = 0 ;
26428 int val1 ;
26429 int ecode1 = 0 ;
26430 int val2 ;
26431 int ecode2 = 0 ;
26432 PyObject * obj0 = 0 ;
26433 PyObject * obj1 = 0 ;
26434 char * kwnames[] = {
26435 (char *) "type",(char *) "winid", NULL
26436 };
26437
26438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26439 if (obj0) {
26440 ecode1 = SWIG_AsVal_int(obj0, &val1);
26441 if (!SWIG_IsOK(ecode1)) {
26442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26443 }
26444 arg1 = static_cast< wxEventType >(val1);
26445 }
26446 if (obj1) {
26447 ecode2 = SWIG_AsVal_int(obj1, &val2);
26448 if (!SWIG_IsOK(ecode2)) {
26449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26450 }
26451 arg2 = static_cast< int >(val2);
26452 }
26453 {
26454 PyThreadState* __tstate = wxPyBeginAllowThreads();
26455 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26456 wxPyEndAllowThreads(__tstate);
26457 if (PyErr_Occurred()) SWIG_fail;
26458 }
26459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26460 return resultobj;
26461 fail:
26462 return NULL;
26463 }
26464
26465
26466 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26467 PyObject *obj;
26468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26469 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26470 return SWIG_Py_Void();
26471 }
26472
26473 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26474 return SWIG_Python_InitShadowInstance(args);
26475 }
26476
26477 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26478 PyObject *resultobj = 0;
26479 int arg1 = (int) 0 ;
26480 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26481 wxPyEvent *result = 0 ;
26482 int val1 ;
26483 int ecode1 = 0 ;
26484 int val2 ;
26485 int ecode2 = 0 ;
26486 PyObject * obj0 = 0 ;
26487 PyObject * obj1 = 0 ;
26488 char * kwnames[] = {
26489 (char *) "winid",(char *) "eventType", NULL
26490 };
26491
26492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26493 if (obj0) {
26494 ecode1 = SWIG_AsVal_int(obj0, &val1);
26495 if (!SWIG_IsOK(ecode1)) {
26496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26497 }
26498 arg1 = static_cast< int >(val1);
26499 }
26500 if (obj1) {
26501 ecode2 = SWIG_AsVal_int(obj1, &val2);
26502 if (!SWIG_IsOK(ecode2)) {
26503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26504 }
26505 arg2 = static_cast< wxEventType >(val2);
26506 }
26507 {
26508 PyThreadState* __tstate = wxPyBeginAllowThreads();
26509 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26514 return resultobj;
26515 fail:
26516 return NULL;
26517 }
26518
26519
26520 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26521 PyObject *resultobj = 0;
26522 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26523 void *argp1 = 0 ;
26524 int res1 = 0 ;
26525 PyObject *swig_obj[1] ;
26526
26527 if (!args) SWIG_fail;
26528 swig_obj[0] = args;
26529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26530 if (!SWIG_IsOK(res1)) {
26531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26532 }
26533 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 delete arg1;
26537
26538 wxPyEndAllowThreads(__tstate);
26539 if (PyErr_Occurred()) SWIG_fail;
26540 }
26541 resultobj = SWIG_Py_Void();
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26549 PyObject *resultobj = 0;
26550 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26551 PyObject *arg2 = (PyObject *) 0 ;
26552 void *argp1 = 0 ;
26553 int res1 = 0 ;
26554 PyObject * obj0 = 0 ;
26555 PyObject * obj1 = 0 ;
26556 char * kwnames[] = {
26557 (char *) "self",(char *) "self", NULL
26558 };
26559
26560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26562 if (!SWIG_IsOK(res1)) {
26563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26564 }
26565 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26566 arg2 = obj1;
26567 {
26568 PyThreadState* __tstate = wxPyBeginAllowThreads();
26569 (arg1)->SetSelf(arg2);
26570 wxPyEndAllowThreads(__tstate);
26571 if (PyErr_Occurred()) SWIG_fail;
26572 }
26573 resultobj = SWIG_Py_Void();
26574 return resultobj;
26575 fail:
26576 return NULL;
26577 }
26578
26579
26580 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26581 PyObject *resultobj = 0;
26582 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26583 PyObject *result = 0 ;
26584 void *argp1 = 0 ;
26585 int res1 = 0 ;
26586 PyObject *swig_obj[1] ;
26587
26588 if (!args) SWIG_fail;
26589 swig_obj[0] = args;
26590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26591 if (!SWIG_IsOK(res1)) {
26592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26593 }
26594 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26595 {
26596 PyThreadState* __tstate = wxPyBeginAllowThreads();
26597 result = (PyObject *)(arg1)->GetSelf();
26598 wxPyEndAllowThreads(__tstate);
26599 if (PyErr_Occurred()) SWIG_fail;
26600 }
26601 resultobj = result;
26602 return resultobj;
26603 fail:
26604 return NULL;
26605 }
26606
26607
26608 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26609 PyObject *obj;
26610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26611 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26612 return SWIG_Py_Void();
26613 }
26614
26615 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26616 return SWIG_Python_InitShadowInstance(args);
26617 }
26618
26619 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26620 PyObject *resultobj = 0;
26621 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26622 int arg2 = (int) 0 ;
26623 wxPyCommandEvent *result = 0 ;
26624 int val1 ;
26625 int ecode1 = 0 ;
26626 int val2 ;
26627 int ecode2 = 0 ;
26628 PyObject * obj0 = 0 ;
26629 PyObject * obj1 = 0 ;
26630 char * kwnames[] = {
26631 (char *) "eventType",(char *) "id", NULL
26632 };
26633
26634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26635 if (obj0) {
26636 ecode1 = SWIG_AsVal_int(obj0, &val1);
26637 if (!SWIG_IsOK(ecode1)) {
26638 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26639 }
26640 arg1 = static_cast< wxEventType >(val1);
26641 }
26642 if (obj1) {
26643 ecode2 = SWIG_AsVal_int(obj1, &val2);
26644 if (!SWIG_IsOK(ecode2)) {
26645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26646 }
26647 arg2 = static_cast< int >(val2);
26648 }
26649 {
26650 PyThreadState* __tstate = wxPyBeginAllowThreads();
26651 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26652 wxPyEndAllowThreads(__tstate);
26653 if (PyErr_Occurred()) SWIG_fail;
26654 }
26655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26656 return resultobj;
26657 fail:
26658 return NULL;
26659 }
26660
26661
26662 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26663 PyObject *resultobj = 0;
26664 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26665 void *argp1 = 0 ;
26666 int res1 = 0 ;
26667 PyObject *swig_obj[1] ;
26668
26669 if (!args) SWIG_fail;
26670 swig_obj[0] = args;
26671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26672 if (!SWIG_IsOK(res1)) {
26673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26674 }
26675 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26676 {
26677 PyThreadState* __tstate = wxPyBeginAllowThreads();
26678 delete arg1;
26679
26680 wxPyEndAllowThreads(__tstate);
26681 if (PyErr_Occurred()) SWIG_fail;
26682 }
26683 resultobj = SWIG_Py_Void();
26684 return resultobj;
26685 fail:
26686 return NULL;
26687 }
26688
26689
26690 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26691 PyObject *resultobj = 0;
26692 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26693 PyObject *arg2 = (PyObject *) 0 ;
26694 void *argp1 = 0 ;
26695 int res1 = 0 ;
26696 PyObject * obj0 = 0 ;
26697 PyObject * obj1 = 0 ;
26698 char * kwnames[] = {
26699 (char *) "self",(char *) "self", NULL
26700 };
26701
26702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26704 if (!SWIG_IsOK(res1)) {
26705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26706 }
26707 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26708 arg2 = obj1;
26709 {
26710 PyThreadState* __tstate = wxPyBeginAllowThreads();
26711 (arg1)->SetSelf(arg2);
26712 wxPyEndAllowThreads(__tstate);
26713 if (PyErr_Occurred()) SWIG_fail;
26714 }
26715 resultobj = SWIG_Py_Void();
26716 return resultobj;
26717 fail:
26718 return NULL;
26719 }
26720
26721
26722 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26723 PyObject *resultobj = 0;
26724 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26725 PyObject *result = 0 ;
26726 void *argp1 = 0 ;
26727 int res1 = 0 ;
26728 PyObject *swig_obj[1] ;
26729
26730 if (!args) SWIG_fail;
26731 swig_obj[0] = args;
26732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26733 if (!SWIG_IsOK(res1)) {
26734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26735 }
26736 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26737 {
26738 PyThreadState* __tstate = wxPyBeginAllowThreads();
26739 result = (PyObject *)(arg1)->GetSelf();
26740 wxPyEndAllowThreads(__tstate);
26741 if (PyErr_Occurred()) SWIG_fail;
26742 }
26743 resultobj = result;
26744 return resultobj;
26745 fail:
26746 return NULL;
26747 }
26748
26749
26750 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26751 PyObject *obj;
26752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26753 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26754 return SWIG_Py_Void();
26755 }
26756
26757 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26758 return SWIG_Python_InitShadowInstance(args);
26759 }
26760
26761 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26762 PyObject *resultobj = 0;
26763 wxWindow *arg1 = (wxWindow *) 0 ;
26764 wxDateTime *arg2 = 0 ;
26765 wxEventType arg3 ;
26766 wxDateEvent *result = 0 ;
26767 void *argp1 = 0 ;
26768 int res1 = 0 ;
26769 void *argp2 = 0 ;
26770 int res2 = 0 ;
26771 int val3 ;
26772 int ecode3 = 0 ;
26773 PyObject * obj0 = 0 ;
26774 PyObject * obj1 = 0 ;
26775 PyObject * obj2 = 0 ;
26776 char * kwnames[] = {
26777 (char *) "win",(char *) "dt",(char *) "type", NULL
26778 };
26779
26780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26782 if (!SWIG_IsOK(res1)) {
26783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26784 }
26785 arg1 = reinterpret_cast< wxWindow * >(argp1);
26786 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26787 if (!SWIG_IsOK(res2)) {
26788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26789 }
26790 if (!argp2) {
26791 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26792 }
26793 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26794 ecode3 = SWIG_AsVal_int(obj2, &val3);
26795 if (!SWIG_IsOK(ecode3)) {
26796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26797 }
26798 arg3 = static_cast< wxEventType >(val3);
26799 {
26800 PyThreadState* __tstate = wxPyBeginAllowThreads();
26801 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26813 PyObject *resultobj = 0;
26814 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26815 wxDateTime *result = 0 ;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 PyObject *swig_obj[1] ;
26819
26820 if (!args) SWIG_fail;
26821 swig_obj[0] = args;
26822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26823 if (!SWIG_IsOK(res1)) {
26824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26825 }
26826 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 {
26830 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26831 result = (wxDateTime *) &_result_ref;
26832 }
26833 wxPyEndAllowThreads(__tstate);
26834 if (PyErr_Occurred()) SWIG_fail;
26835 }
26836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26837 return resultobj;
26838 fail:
26839 return NULL;
26840 }
26841
26842
26843 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26844 PyObject *resultobj = 0;
26845 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26846 wxDateTime *arg2 = 0 ;
26847 void *argp1 = 0 ;
26848 int res1 = 0 ;
26849 void *argp2 = 0 ;
26850 int res2 = 0 ;
26851 PyObject * obj0 = 0 ;
26852 PyObject * obj1 = 0 ;
26853 char * kwnames[] = {
26854 (char *) "self",(char *) "date", NULL
26855 };
26856
26857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26859 if (!SWIG_IsOK(res1)) {
26860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26861 }
26862 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26863 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26864 if (!SWIG_IsOK(res2)) {
26865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26866 }
26867 if (!argp2) {
26868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26869 }
26870 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26871 {
26872 PyThreadState* __tstate = wxPyBeginAllowThreads();
26873 (arg1)->SetDate((wxDateTime const &)*arg2);
26874 wxPyEndAllowThreads(__tstate);
26875 if (PyErr_Occurred()) SWIG_fail;
26876 }
26877 resultobj = SWIG_Py_Void();
26878 return resultobj;
26879 fail:
26880 return NULL;
26881 }
26882
26883
26884 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26885 PyObject *obj;
26886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26887 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26888 return SWIG_Py_Void();
26889 }
26890
26891 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26892 return SWIG_Python_InitShadowInstance(args);
26893 }
26894
26895 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26896 PyObject *resultobj = 0;
26897 wxPyApp *result = 0 ;
26898
26899 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26900 {
26901 PyThreadState* __tstate = wxPyBeginAllowThreads();
26902 result = (wxPyApp *)new_wxPyApp();
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26907 return resultobj;
26908 fail:
26909 return NULL;
26910 }
26911
26912
26913 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26914 PyObject *resultobj = 0;
26915 wxPyApp *arg1 = (wxPyApp *) 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_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26923 if (!SWIG_IsOK(res1)) {
26924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26925 }
26926 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 delete arg1;
26930
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 resultobj = SWIG_Py_Void();
26935 return resultobj;
26936 fail:
26937 return NULL;
26938 }
26939
26940
26941 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26942 PyObject *resultobj = 0;
26943 wxPyApp *arg1 = (wxPyApp *) 0 ;
26944 PyObject *arg2 = (PyObject *) 0 ;
26945 PyObject *arg3 = (PyObject *) 0 ;
26946 bool arg4 ;
26947 void *argp1 = 0 ;
26948 int res1 = 0 ;
26949 bool val4 ;
26950 int ecode4 = 0 ;
26951 PyObject * obj0 = 0 ;
26952 PyObject * obj1 = 0 ;
26953 PyObject * obj2 = 0 ;
26954 PyObject * obj3 = 0 ;
26955 char * kwnames[] = {
26956 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26957 };
26958
26959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26961 if (!SWIG_IsOK(res1)) {
26962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26963 }
26964 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26965 arg2 = obj1;
26966 arg3 = obj2;
26967 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26968 if (!SWIG_IsOK(ecode4)) {
26969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26970 }
26971 arg4 = static_cast< bool >(val4);
26972 {
26973 PyThreadState* __tstate = wxPyBeginAllowThreads();
26974 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 resultobj = SWIG_Py_Void();
26979 return resultobj;
26980 fail:
26981 return NULL;
26982 }
26983
26984
26985 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26986 PyObject *resultobj = 0;
26987 wxPyApp *arg1 = (wxPyApp *) 0 ;
26988 wxString result;
26989 void *argp1 = 0 ;
26990 int res1 = 0 ;
26991 PyObject *swig_obj[1] ;
26992
26993 if (!args) SWIG_fail;
26994 swig_obj[0] = args;
26995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26996 if (!SWIG_IsOK(res1)) {
26997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26998 }
26999 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27000 {
27001 PyThreadState* __tstate = wxPyBeginAllowThreads();
27002 result = ((wxPyApp const *)arg1)->GetAppName();
27003 wxPyEndAllowThreads(__tstate);
27004 if (PyErr_Occurred()) SWIG_fail;
27005 }
27006 {
27007 #if wxUSE_UNICODE
27008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27009 #else
27010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27011 #endif
27012 }
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj = 0;
27021 wxPyApp *arg1 = (wxPyApp *) 0 ;
27022 wxString *arg2 = 0 ;
27023 void *argp1 = 0 ;
27024 int res1 = 0 ;
27025 bool temp2 = false ;
27026 PyObject * obj0 = 0 ;
27027 PyObject * obj1 = 0 ;
27028 char * kwnames[] = {
27029 (char *) "self",(char *) "name", NULL
27030 };
27031
27032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27034 if (!SWIG_IsOK(res1)) {
27035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27036 }
27037 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27038 {
27039 arg2 = wxString_in_helper(obj1);
27040 if (arg2 == NULL) SWIG_fail;
27041 temp2 = true;
27042 }
27043 {
27044 PyThreadState* __tstate = wxPyBeginAllowThreads();
27045 (arg1)->SetAppName((wxString const &)*arg2);
27046 wxPyEndAllowThreads(__tstate);
27047 if (PyErr_Occurred()) SWIG_fail;
27048 }
27049 resultobj = SWIG_Py_Void();
27050 {
27051 if (temp2)
27052 delete arg2;
27053 }
27054 return resultobj;
27055 fail:
27056 {
27057 if (temp2)
27058 delete arg2;
27059 }
27060 return NULL;
27061 }
27062
27063
27064 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27065 PyObject *resultobj = 0;
27066 wxPyApp *arg1 = (wxPyApp *) 0 ;
27067 wxString result;
27068 void *argp1 = 0 ;
27069 int res1 = 0 ;
27070 PyObject *swig_obj[1] ;
27071
27072 if (!args) SWIG_fail;
27073 swig_obj[0] = args;
27074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27075 if (!SWIG_IsOK(res1)) {
27076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27077 }
27078 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27079 {
27080 PyThreadState* __tstate = wxPyBeginAllowThreads();
27081 result = ((wxPyApp const *)arg1)->GetClassName();
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 {
27086 #if wxUSE_UNICODE
27087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27088 #else
27089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27090 #endif
27091 }
27092 return resultobj;
27093 fail:
27094 return NULL;
27095 }
27096
27097
27098 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27099 PyObject *resultobj = 0;
27100 wxPyApp *arg1 = (wxPyApp *) 0 ;
27101 wxString *arg2 = 0 ;
27102 void *argp1 = 0 ;
27103 int res1 = 0 ;
27104 bool temp2 = false ;
27105 PyObject * obj0 = 0 ;
27106 PyObject * obj1 = 0 ;
27107 char * kwnames[] = {
27108 (char *) "self",(char *) "name", NULL
27109 };
27110
27111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27113 if (!SWIG_IsOK(res1)) {
27114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27115 }
27116 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27117 {
27118 arg2 = wxString_in_helper(obj1);
27119 if (arg2 == NULL) SWIG_fail;
27120 temp2 = true;
27121 }
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 (arg1)->SetClassName((wxString const &)*arg2);
27125 wxPyEndAllowThreads(__tstate);
27126 if (PyErr_Occurred()) SWIG_fail;
27127 }
27128 resultobj = SWIG_Py_Void();
27129 {
27130 if (temp2)
27131 delete arg2;
27132 }
27133 return resultobj;
27134 fail:
27135 {
27136 if (temp2)
27137 delete arg2;
27138 }
27139 return NULL;
27140 }
27141
27142
27143 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27144 PyObject *resultobj = 0;
27145 wxPyApp *arg1 = (wxPyApp *) 0 ;
27146 wxString *result = 0 ;
27147 void *argp1 = 0 ;
27148 int res1 = 0 ;
27149 PyObject *swig_obj[1] ;
27150
27151 if (!args) SWIG_fail;
27152 swig_obj[0] = args;
27153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27154 if (!SWIG_IsOK(res1)) {
27155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27156 }
27157 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27158 {
27159 PyThreadState* __tstate = wxPyBeginAllowThreads();
27160 {
27161 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27162 result = (wxString *) &_result_ref;
27163 }
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 {
27168 #if wxUSE_UNICODE
27169 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27170 #else
27171 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27172 #endif
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj = 0;
27182 wxPyApp *arg1 = (wxPyApp *) 0 ;
27183 wxString *arg2 = 0 ;
27184 void *argp1 = 0 ;
27185 int res1 = 0 ;
27186 bool temp2 = false ;
27187 PyObject * obj0 = 0 ;
27188 PyObject * obj1 = 0 ;
27189 char * kwnames[] = {
27190 (char *) "self",(char *) "name", NULL
27191 };
27192
27193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27195 if (!SWIG_IsOK(res1)) {
27196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27197 }
27198 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27199 {
27200 arg2 = wxString_in_helper(obj1);
27201 if (arg2 == NULL) SWIG_fail;
27202 temp2 = true;
27203 }
27204 {
27205 PyThreadState* __tstate = wxPyBeginAllowThreads();
27206 (arg1)->SetVendorName((wxString const &)*arg2);
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 resultobj = SWIG_Py_Void();
27211 {
27212 if (temp2)
27213 delete arg2;
27214 }
27215 return resultobj;
27216 fail:
27217 {
27218 if (temp2)
27219 delete arg2;
27220 }
27221 return NULL;
27222 }
27223
27224
27225 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27226 PyObject *resultobj = 0;
27227 wxPyApp *arg1 = (wxPyApp *) 0 ;
27228 wxAppTraits *result = 0 ;
27229 void *argp1 = 0 ;
27230 int res1 = 0 ;
27231 PyObject *swig_obj[1] ;
27232
27233 if (!args) SWIG_fail;
27234 swig_obj[0] = args;
27235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27236 if (!SWIG_IsOK(res1)) {
27237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27238 }
27239 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (wxAppTraits *)(arg1)->GetTraits();
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27254 PyObject *resultobj = 0;
27255 wxPyApp *arg1 = (wxPyApp *) 0 ;
27256 void *argp1 = 0 ;
27257 int res1 = 0 ;
27258 PyObject *swig_obj[1] ;
27259
27260 if (!args) SWIG_fail;
27261 swig_obj[0] = args;
27262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27263 if (!SWIG_IsOK(res1)) {
27264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27265 }
27266 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 (arg1)->ProcessPendingEvents();
27270 wxPyEndAllowThreads(__tstate);
27271 if (PyErr_Occurred()) SWIG_fail;
27272 }
27273 resultobj = SWIG_Py_Void();
27274 return resultobj;
27275 fail:
27276 return NULL;
27277 }
27278
27279
27280 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27281 PyObject *resultobj = 0;
27282 wxPyApp *arg1 = (wxPyApp *) 0 ;
27283 bool arg2 = (bool) false ;
27284 bool result;
27285 void *argp1 = 0 ;
27286 int res1 = 0 ;
27287 bool val2 ;
27288 int ecode2 = 0 ;
27289 PyObject * obj0 = 0 ;
27290 PyObject * obj1 = 0 ;
27291 char * kwnames[] = {
27292 (char *) "self",(char *) "onlyIfNeeded", NULL
27293 };
27294
27295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27297 if (!SWIG_IsOK(res1)) {
27298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27299 }
27300 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27301 if (obj1) {
27302 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27303 if (!SWIG_IsOK(ecode2)) {
27304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27305 }
27306 arg2 = static_cast< bool >(val2);
27307 }
27308 {
27309 PyThreadState* __tstate = wxPyBeginAllowThreads();
27310 result = (bool)(arg1)->Yield(arg2);
27311 wxPyEndAllowThreads(__tstate);
27312 if (PyErr_Occurred()) SWIG_fail;
27313 }
27314 {
27315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27316 }
27317 return resultobj;
27318 fail:
27319 return NULL;
27320 }
27321
27322
27323 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27324 PyObject *resultobj = 0;
27325 wxPyApp *arg1 = (wxPyApp *) 0 ;
27326 void *argp1 = 0 ;
27327 int res1 = 0 ;
27328 PyObject *swig_obj[1] ;
27329
27330 if (!args) SWIG_fail;
27331 swig_obj[0] = args;
27332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27333 if (!SWIG_IsOK(res1)) {
27334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27335 }
27336 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 (arg1)->WakeUpIdle();
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 resultobj = SWIG_Py_Void();
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27351 PyObject *resultobj = 0;
27352 bool result;
27353
27354 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27355 {
27356 PyThreadState* __tstate = wxPyBeginAllowThreads();
27357 result = (bool)wxPyApp::IsMainLoopRunning();
27358 wxPyEndAllowThreads(__tstate);
27359 if (PyErr_Occurred()) SWIG_fail;
27360 }
27361 {
27362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27363 }
27364 return resultobj;
27365 fail:
27366 return NULL;
27367 }
27368
27369
27370 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27371 PyObject *resultobj = 0;
27372 wxPyApp *arg1 = (wxPyApp *) 0 ;
27373 int result;
27374 void *argp1 = 0 ;
27375 int res1 = 0 ;
27376 PyObject *swig_obj[1] ;
27377
27378 if (!args) SWIG_fail;
27379 swig_obj[0] = args;
27380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27381 if (!SWIG_IsOK(res1)) {
27382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27383 }
27384 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27385 {
27386 PyThreadState* __tstate = wxPyBeginAllowThreads();
27387 result = (int)(arg1)->MainLoop();
27388 wxPyEndAllowThreads(__tstate);
27389 if (PyErr_Occurred()) SWIG_fail;
27390 }
27391 resultobj = SWIG_From_int(static_cast< int >(result));
27392 return resultobj;
27393 fail:
27394 return NULL;
27395 }
27396
27397
27398 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27399 PyObject *resultobj = 0;
27400 wxPyApp *arg1 = (wxPyApp *) 0 ;
27401 void *argp1 = 0 ;
27402 int res1 = 0 ;
27403 PyObject *swig_obj[1] ;
27404
27405 if (!args) SWIG_fail;
27406 swig_obj[0] = args;
27407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27408 if (!SWIG_IsOK(res1)) {
27409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27410 }
27411 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27412 {
27413 PyThreadState* __tstate = wxPyBeginAllowThreads();
27414 (arg1)->Exit();
27415 wxPyEndAllowThreads(__tstate);
27416 if (PyErr_Occurred()) SWIG_fail;
27417 }
27418 resultobj = SWIG_Py_Void();
27419 return resultobj;
27420 fail:
27421 return NULL;
27422 }
27423
27424
27425 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27426 PyObject *resultobj = 0;
27427 wxPyApp *arg1 = (wxPyApp *) 0 ;
27428 void *argp1 = 0 ;
27429 int res1 = 0 ;
27430 PyObject *swig_obj[1] ;
27431
27432 if (!args) SWIG_fail;
27433 swig_obj[0] = args;
27434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27435 if (!SWIG_IsOK(res1)) {
27436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27437 }
27438 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 (arg1)->ExitMainLoop();
27442 wxPyEndAllowThreads(__tstate);
27443 if (PyErr_Occurred()) SWIG_fail;
27444 }
27445 resultobj = SWIG_Py_Void();
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27453 PyObject *resultobj = 0;
27454 wxPyApp *arg1 = (wxPyApp *) 0 ;
27455 bool result;
27456 void *argp1 = 0 ;
27457 int res1 = 0 ;
27458 PyObject *swig_obj[1] ;
27459
27460 if (!args) SWIG_fail;
27461 swig_obj[0] = args;
27462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27465 }
27466 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27467 {
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 result = (bool)(arg1)->Pending();
27470 wxPyEndAllowThreads(__tstate);
27471 if (PyErr_Occurred()) SWIG_fail;
27472 }
27473 {
27474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27475 }
27476 return resultobj;
27477 fail:
27478 return NULL;
27479 }
27480
27481
27482 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27483 PyObject *resultobj = 0;
27484 wxPyApp *arg1 = (wxPyApp *) 0 ;
27485 bool result;
27486 void *argp1 = 0 ;
27487 int res1 = 0 ;
27488 PyObject *swig_obj[1] ;
27489
27490 if (!args) SWIG_fail;
27491 swig_obj[0] = args;
27492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27493 if (!SWIG_IsOK(res1)) {
27494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27495 }
27496 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 result = (bool)(arg1)->Dispatch();
27500 wxPyEndAllowThreads(__tstate);
27501 if (PyErr_Occurred()) SWIG_fail;
27502 }
27503 {
27504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27505 }
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27513 PyObject *resultobj = 0;
27514 wxPyApp *arg1 = (wxPyApp *) 0 ;
27515 bool result;
27516 void *argp1 = 0 ;
27517 int res1 = 0 ;
27518 PyObject *swig_obj[1] ;
27519
27520 if (!args) SWIG_fail;
27521 swig_obj[0] = args;
27522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27523 if (!SWIG_IsOK(res1)) {
27524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27525 }
27526 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27527 {
27528 PyThreadState* __tstate = wxPyBeginAllowThreads();
27529 result = (bool)(arg1)->ProcessIdle();
27530 wxPyEndAllowThreads(__tstate);
27531 if (PyErr_Occurred()) SWIG_fail;
27532 }
27533 {
27534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27535 }
27536 return resultobj;
27537 fail:
27538 return NULL;
27539 }
27540
27541
27542 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27543 PyObject *resultobj = 0;
27544 wxPyApp *arg1 = (wxPyApp *) 0 ;
27545 wxWindow *arg2 = (wxWindow *) 0 ;
27546 wxIdleEvent *arg3 = 0 ;
27547 bool result;
27548 void *argp1 = 0 ;
27549 int res1 = 0 ;
27550 void *argp2 = 0 ;
27551 int res2 = 0 ;
27552 void *argp3 = 0 ;
27553 int res3 = 0 ;
27554 PyObject * obj0 = 0 ;
27555 PyObject * obj1 = 0 ;
27556 PyObject * obj2 = 0 ;
27557 char * kwnames[] = {
27558 (char *) "self",(char *) "win",(char *) "event", NULL
27559 };
27560
27561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27563 if (!SWIG_IsOK(res1)) {
27564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27565 }
27566 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27567 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27568 if (!SWIG_IsOK(res2)) {
27569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27570 }
27571 arg2 = reinterpret_cast< wxWindow * >(argp2);
27572 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27573 if (!SWIG_IsOK(res3)) {
27574 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27575 }
27576 if (!argp3) {
27577 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27578 }
27579 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 {
27587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27588 }
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27596 PyObject *resultobj = 0;
27597 wxPyApp *arg1 = (wxPyApp *) 0 ;
27598 bool result;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 PyObject *swig_obj[1] ;
27602
27603 if (!args) SWIG_fail;
27604 swig_obj[0] = args;
27605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27606 if (!SWIG_IsOK(res1)) {
27607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27608 }
27609 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = (bool)((wxPyApp const *)arg1)->IsActive();
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 {
27617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27618 }
27619 return resultobj;
27620 fail:
27621 return NULL;
27622 }
27623
27624
27625 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27626 PyObject *resultobj = 0;
27627 wxPyApp *arg1 = (wxPyApp *) 0 ;
27628 wxWindow *arg2 = (wxWindow *) 0 ;
27629 void *argp1 = 0 ;
27630 int res1 = 0 ;
27631 void *argp2 = 0 ;
27632 int res2 = 0 ;
27633 PyObject * obj0 = 0 ;
27634 PyObject * obj1 = 0 ;
27635 char * kwnames[] = {
27636 (char *) "self",(char *) "win", NULL
27637 };
27638
27639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27641 if (!SWIG_IsOK(res1)) {
27642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27643 }
27644 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27646 if (!SWIG_IsOK(res2)) {
27647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27648 }
27649 arg2 = reinterpret_cast< wxWindow * >(argp2);
27650 {
27651 PyThreadState* __tstate = wxPyBeginAllowThreads();
27652 (arg1)->SetTopWindow(arg2);
27653 wxPyEndAllowThreads(__tstate);
27654 if (PyErr_Occurred()) SWIG_fail;
27655 }
27656 resultobj = SWIG_Py_Void();
27657 return resultobj;
27658 fail:
27659 return NULL;
27660 }
27661
27662
27663 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27664 PyObject *resultobj = 0;
27665 wxPyApp *arg1 = (wxPyApp *) 0 ;
27666 wxWindow *result = 0 ;
27667 void *argp1 = 0 ;
27668 int res1 = 0 ;
27669 PyObject *swig_obj[1] ;
27670
27671 if (!args) SWIG_fail;
27672 swig_obj[0] = args;
27673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27674 if (!SWIG_IsOK(res1)) {
27675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27676 }
27677 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27678 {
27679 PyThreadState* __tstate = wxPyBeginAllowThreads();
27680 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27681 wxPyEndAllowThreads(__tstate);
27682 if (PyErr_Occurred()) SWIG_fail;
27683 }
27684 {
27685 resultobj = wxPyMake_wxObject(result, (bool)0);
27686 }
27687 return resultobj;
27688 fail:
27689 return NULL;
27690 }
27691
27692
27693 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27694 PyObject *resultobj = 0;
27695 wxPyApp *arg1 = (wxPyApp *) 0 ;
27696 bool arg2 ;
27697 void *argp1 = 0 ;
27698 int res1 = 0 ;
27699 bool val2 ;
27700 int ecode2 = 0 ;
27701 PyObject * obj0 = 0 ;
27702 PyObject * obj1 = 0 ;
27703 char * kwnames[] = {
27704 (char *) "self",(char *) "flag", NULL
27705 };
27706
27707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27709 if (!SWIG_IsOK(res1)) {
27710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27711 }
27712 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27713 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27714 if (!SWIG_IsOK(ecode2)) {
27715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27716 }
27717 arg2 = static_cast< bool >(val2);
27718 {
27719 PyThreadState* __tstate = wxPyBeginAllowThreads();
27720 (arg1)->SetExitOnFrameDelete(arg2);
27721 wxPyEndAllowThreads(__tstate);
27722 if (PyErr_Occurred()) SWIG_fail;
27723 }
27724 resultobj = SWIG_Py_Void();
27725 return resultobj;
27726 fail:
27727 return NULL;
27728 }
27729
27730
27731 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27732 PyObject *resultobj = 0;
27733 wxPyApp *arg1 = (wxPyApp *) 0 ;
27734 bool result;
27735 void *argp1 = 0 ;
27736 int res1 = 0 ;
27737 PyObject *swig_obj[1] ;
27738
27739 if (!args) SWIG_fail;
27740 swig_obj[0] = args;
27741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27742 if (!SWIG_IsOK(res1)) {
27743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27744 }
27745 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27746 {
27747 PyThreadState* __tstate = wxPyBeginAllowThreads();
27748 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27749 wxPyEndAllowThreads(__tstate);
27750 if (PyErr_Occurred()) SWIG_fail;
27751 }
27752 {
27753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27754 }
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27762 PyObject *resultobj = 0;
27763 wxPyApp *arg1 = (wxPyApp *) 0 ;
27764 bool arg2 ;
27765 void *argp1 = 0 ;
27766 int res1 = 0 ;
27767 bool val2 ;
27768 int ecode2 = 0 ;
27769 PyObject * obj0 = 0 ;
27770 PyObject * obj1 = 0 ;
27771 char * kwnames[] = {
27772 (char *) "self",(char *) "flag", NULL
27773 };
27774
27775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27777 if (!SWIG_IsOK(res1)) {
27778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27779 }
27780 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27781 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27782 if (!SWIG_IsOK(ecode2)) {
27783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27784 }
27785 arg2 = static_cast< bool >(val2);
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 (arg1)->SetUseBestVisual(arg2);
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 resultobj = SWIG_Py_Void();
27793 return resultobj;
27794 fail:
27795 return NULL;
27796 }
27797
27798
27799 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27800 PyObject *resultobj = 0;
27801 wxPyApp *arg1 = (wxPyApp *) 0 ;
27802 bool result;
27803 void *argp1 = 0 ;
27804 int res1 = 0 ;
27805 PyObject *swig_obj[1] ;
27806
27807 if (!args) SWIG_fail;
27808 swig_obj[0] = args;
27809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27810 if (!SWIG_IsOK(res1)) {
27811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27812 }
27813 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 {
27821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27822 }
27823 return resultobj;
27824 fail:
27825 return NULL;
27826 }
27827
27828
27829 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27830 PyObject *resultobj = 0;
27831 wxPyApp *arg1 = (wxPyApp *) 0 ;
27832 int arg2 ;
27833 void *argp1 = 0 ;
27834 int res1 = 0 ;
27835 int val2 ;
27836 int ecode2 = 0 ;
27837 PyObject * obj0 = 0 ;
27838 PyObject * obj1 = 0 ;
27839 char * kwnames[] = {
27840 (char *) "self",(char *) "mode", NULL
27841 };
27842
27843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27845 if (!SWIG_IsOK(res1)) {
27846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27847 }
27848 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27849 ecode2 = SWIG_AsVal_int(obj1, &val2);
27850 if (!SWIG_IsOK(ecode2)) {
27851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27852 }
27853 arg2 = static_cast< int >(val2);
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 (arg1)->SetPrintMode(arg2);
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 resultobj = SWIG_Py_Void();
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27868 PyObject *resultobj = 0;
27869 wxPyApp *arg1 = (wxPyApp *) 0 ;
27870 int result;
27871 void *argp1 = 0 ;
27872 int res1 = 0 ;
27873 PyObject *swig_obj[1] ;
27874
27875 if (!args) SWIG_fail;
27876 swig_obj[0] = args;
27877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27880 }
27881 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 resultobj = SWIG_From_int(static_cast< int >(result));
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27896 PyObject *resultobj = 0;
27897 wxPyApp *arg1 = (wxPyApp *) 0 ;
27898 int arg2 ;
27899 void *argp1 = 0 ;
27900 int res1 = 0 ;
27901 int val2 ;
27902 int ecode2 = 0 ;
27903 PyObject * obj0 = 0 ;
27904 PyObject * obj1 = 0 ;
27905 char * kwnames[] = {
27906 (char *) "self",(char *) "mode", NULL
27907 };
27908
27909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27911 if (!SWIG_IsOK(res1)) {
27912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27913 }
27914 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27915 ecode2 = SWIG_AsVal_int(obj1, &val2);
27916 if (!SWIG_IsOK(ecode2)) {
27917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27918 }
27919 arg2 = static_cast< int >(val2);
27920 {
27921 PyThreadState* __tstate = wxPyBeginAllowThreads();
27922 (arg1)->SetAssertMode(arg2);
27923 wxPyEndAllowThreads(__tstate);
27924 if (PyErr_Occurred()) SWIG_fail;
27925 }
27926 resultobj = SWIG_Py_Void();
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27934 PyObject *resultobj = 0;
27935 wxPyApp *arg1 = (wxPyApp *) 0 ;
27936 int result;
27937 void *argp1 = 0 ;
27938 int res1 = 0 ;
27939 PyObject *swig_obj[1] ;
27940
27941 if (!args) SWIG_fail;
27942 swig_obj[0] = args;
27943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27944 if (!SWIG_IsOK(res1)) {
27945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27946 }
27947 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27948 {
27949 PyThreadState* __tstate = wxPyBeginAllowThreads();
27950 result = (int)(arg1)->GetAssertMode();
27951 wxPyEndAllowThreads(__tstate);
27952 if (PyErr_Occurred()) SWIG_fail;
27953 }
27954 resultobj = SWIG_From_int(static_cast< int >(result));
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27962 PyObject *resultobj = 0;
27963 bool result;
27964
27965 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27966 {
27967 PyThreadState* __tstate = wxPyBeginAllowThreads();
27968 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27969 wxPyEndAllowThreads(__tstate);
27970 if (PyErr_Occurred()) SWIG_fail;
27971 }
27972 {
27973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27974 }
27975 return resultobj;
27976 fail:
27977 return NULL;
27978 }
27979
27980
27981 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27982 PyObject *resultobj = 0;
27983 long result;
27984
27985 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27986 {
27987 PyThreadState* __tstate = wxPyBeginAllowThreads();
27988 result = (long)wxPyApp::GetMacAboutMenuItemId();
27989 wxPyEndAllowThreads(__tstate);
27990 if (PyErr_Occurred()) SWIG_fail;
27991 }
27992 resultobj = SWIG_From_long(static_cast< long >(result));
27993 return resultobj;
27994 fail:
27995 return NULL;
27996 }
27997
27998
27999 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28000 PyObject *resultobj = 0;
28001 long result;
28002
28003 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28004 {
28005 PyThreadState* __tstate = wxPyBeginAllowThreads();
28006 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28007 wxPyEndAllowThreads(__tstate);
28008 if (PyErr_Occurred()) SWIG_fail;
28009 }
28010 resultobj = SWIG_From_long(static_cast< long >(result));
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28018 PyObject *resultobj = 0;
28019 long result;
28020
28021 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 result = (long)wxPyApp::GetMacExitMenuItemId();
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 resultobj = SWIG_From_long(static_cast< long >(result));
28029 return resultobj;
28030 fail:
28031 return NULL;
28032 }
28033
28034
28035 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28036 PyObject *resultobj = 0;
28037 wxString result;
28038
28039 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28040 {
28041 PyThreadState* __tstate = wxPyBeginAllowThreads();
28042 result = wxPyApp::GetMacHelpMenuTitleName();
28043 wxPyEndAllowThreads(__tstate);
28044 if (PyErr_Occurred()) SWIG_fail;
28045 }
28046 {
28047 #if wxUSE_UNICODE
28048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28049 #else
28050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28051 #endif
28052 }
28053 return resultobj;
28054 fail:
28055 return NULL;
28056 }
28057
28058
28059 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28060 PyObject *resultobj = 0;
28061 bool arg1 ;
28062 bool val1 ;
28063 int ecode1 = 0 ;
28064 PyObject * obj0 = 0 ;
28065 char * kwnames[] = {
28066 (char *) "val", NULL
28067 };
28068
28069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28070 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28071 if (!SWIG_IsOK(ecode1)) {
28072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28073 }
28074 arg1 = static_cast< bool >(val1);
28075 {
28076 PyThreadState* __tstate = wxPyBeginAllowThreads();
28077 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28078 wxPyEndAllowThreads(__tstate);
28079 if (PyErr_Occurred()) SWIG_fail;
28080 }
28081 resultobj = SWIG_Py_Void();
28082 return resultobj;
28083 fail:
28084 return NULL;
28085 }
28086
28087
28088 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28089 PyObject *resultobj = 0;
28090 long arg1 ;
28091 long val1 ;
28092 int ecode1 = 0 ;
28093 PyObject * obj0 = 0 ;
28094 char * kwnames[] = {
28095 (char *) "val", NULL
28096 };
28097
28098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28099 ecode1 = SWIG_AsVal_long(obj0, &val1);
28100 if (!SWIG_IsOK(ecode1)) {
28101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28102 }
28103 arg1 = static_cast< long >(val1);
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 wxPyApp::SetMacAboutMenuItemId(arg1);
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 resultobj = SWIG_Py_Void();
28111 return resultobj;
28112 fail:
28113 return NULL;
28114 }
28115
28116
28117 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28118 PyObject *resultobj = 0;
28119 long arg1 ;
28120 long val1 ;
28121 int ecode1 = 0 ;
28122 PyObject * obj0 = 0 ;
28123 char * kwnames[] = {
28124 (char *) "val", NULL
28125 };
28126
28127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28128 ecode1 = SWIG_AsVal_long(obj0, &val1);
28129 if (!SWIG_IsOK(ecode1)) {
28130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28131 }
28132 arg1 = static_cast< long >(val1);
28133 {
28134 PyThreadState* __tstate = wxPyBeginAllowThreads();
28135 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28136 wxPyEndAllowThreads(__tstate);
28137 if (PyErr_Occurred()) SWIG_fail;
28138 }
28139 resultobj = SWIG_Py_Void();
28140 return resultobj;
28141 fail:
28142 return NULL;
28143 }
28144
28145
28146 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28147 PyObject *resultobj = 0;
28148 long arg1 ;
28149 long val1 ;
28150 int ecode1 = 0 ;
28151 PyObject * obj0 = 0 ;
28152 char * kwnames[] = {
28153 (char *) "val", NULL
28154 };
28155
28156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28157 ecode1 = SWIG_AsVal_long(obj0, &val1);
28158 if (!SWIG_IsOK(ecode1)) {
28159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28160 }
28161 arg1 = static_cast< long >(val1);
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 wxPyApp::SetMacExitMenuItemId(arg1);
28165 wxPyEndAllowThreads(__tstate);
28166 if (PyErr_Occurred()) SWIG_fail;
28167 }
28168 resultobj = SWIG_Py_Void();
28169 return resultobj;
28170 fail:
28171 return NULL;
28172 }
28173
28174
28175 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28176 PyObject *resultobj = 0;
28177 wxString *arg1 = 0 ;
28178 bool temp1 = false ;
28179 PyObject * obj0 = 0 ;
28180 char * kwnames[] = {
28181 (char *) "val", NULL
28182 };
28183
28184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28185 {
28186 arg1 = wxString_in_helper(obj0);
28187 if (arg1 == NULL) SWIG_fail;
28188 temp1 = true;
28189 }
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28193 wxPyEndAllowThreads(__tstate);
28194 if (PyErr_Occurred()) SWIG_fail;
28195 }
28196 resultobj = SWIG_Py_Void();
28197 {
28198 if (temp1)
28199 delete arg1;
28200 }
28201 return resultobj;
28202 fail:
28203 {
28204 if (temp1)
28205 delete arg1;
28206 }
28207 return NULL;
28208 }
28209
28210
28211 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28212 PyObject *resultobj = 0;
28213 wxPyApp *arg1 = (wxPyApp *) 0 ;
28214 void *argp1 = 0 ;
28215 int res1 = 0 ;
28216 PyObject *swig_obj[1] ;
28217
28218 if (!args) SWIG_fail;
28219 swig_obj[0] = args;
28220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28221 if (!SWIG_IsOK(res1)) {
28222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28223 }
28224 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28225 {
28226 PyThreadState* __tstate = wxPyBeginAllowThreads();
28227 (arg1)->_BootstrapApp();
28228 wxPyEndAllowThreads(__tstate);
28229 if (PyErr_Occurred()) SWIG_fail;
28230 }
28231 resultobj = SWIG_Py_Void();
28232 return resultobj;
28233 fail:
28234 return NULL;
28235 }
28236
28237
28238 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28239 PyObject *resultobj = 0;
28240 int result;
28241
28242 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28243 {
28244 PyThreadState* __tstate = wxPyBeginAllowThreads();
28245 result = (int)wxPyApp_GetComCtl32Version();
28246 wxPyEndAllowThreads(__tstate);
28247 if (PyErr_Occurred()) SWIG_fail;
28248 }
28249 resultobj = SWIG_From_int(static_cast< int >(result));
28250 return resultobj;
28251 fail:
28252 return NULL;
28253 }
28254
28255
28256 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28257 PyObject *obj;
28258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28259 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28260 return SWIG_Py_Void();
28261 }
28262
28263 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28264 return SWIG_Python_InitShadowInstance(args);
28265 }
28266
28267 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28268 PyObject *resultobj = 0;
28269
28270 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28271 {
28272 PyThreadState* __tstate = wxPyBeginAllowThreads();
28273 wxExit();
28274 wxPyEndAllowThreads(__tstate);
28275 if (PyErr_Occurred()) SWIG_fail;
28276 }
28277 resultobj = SWIG_Py_Void();
28278 return resultobj;
28279 fail:
28280 return NULL;
28281 }
28282
28283
28284 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28285 PyObject *resultobj = 0;
28286 bool result;
28287
28288 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 result = (bool)wxYield();
28292 wxPyEndAllowThreads(__tstate);
28293 if (PyErr_Occurred()) SWIG_fail;
28294 }
28295 {
28296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28297 }
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28305 PyObject *resultobj = 0;
28306 bool result;
28307
28308 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28309 {
28310 PyThreadState* __tstate = wxPyBeginAllowThreads();
28311 result = (bool)wxYieldIfNeeded();
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 {
28316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28317 }
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28325 PyObject *resultobj = 0;
28326 wxWindow *arg1 = (wxWindow *) NULL ;
28327 bool arg2 = (bool) false ;
28328 bool result;
28329 void *argp1 = 0 ;
28330 int res1 = 0 ;
28331 bool val2 ;
28332 int ecode2 = 0 ;
28333 PyObject * obj0 = 0 ;
28334 PyObject * obj1 = 0 ;
28335 char * kwnames[] = {
28336 (char *) "win",(char *) "onlyIfNeeded", NULL
28337 };
28338
28339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28340 if (obj0) {
28341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28342 if (!SWIG_IsOK(res1)) {
28343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28344 }
28345 arg1 = reinterpret_cast< wxWindow * >(argp1);
28346 }
28347 if (obj1) {
28348 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28349 if (!SWIG_IsOK(ecode2)) {
28350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28351 }
28352 arg2 = static_cast< bool >(val2);
28353 }
28354 {
28355 PyThreadState* __tstate = wxPyBeginAllowThreads();
28356 result = (bool)wxSafeYield(arg1,arg2);
28357 wxPyEndAllowThreads(__tstate);
28358 if (PyErr_Occurred()) SWIG_fail;
28359 }
28360 {
28361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28362 }
28363 return resultobj;
28364 fail:
28365 return NULL;
28366 }
28367
28368
28369 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28370 PyObject *resultobj = 0;
28371
28372 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 wxWakeUpIdle();
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 resultobj = SWIG_Py_Void();
28380 return resultobj;
28381 fail:
28382 return NULL;
28383 }
28384
28385
28386 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28387 PyObject *resultobj = 0;
28388 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28389 wxEvent *arg2 = 0 ;
28390 void *argp1 = 0 ;
28391 int res1 = 0 ;
28392 void *argp2 = 0 ;
28393 int res2 = 0 ;
28394 PyObject * obj0 = 0 ;
28395 PyObject * obj1 = 0 ;
28396 char * kwnames[] = {
28397 (char *) "dest",(char *) "event", NULL
28398 };
28399
28400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28402 if (!SWIG_IsOK(res1)) {
28403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28404 }
28405 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28406 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28407 if (!SWIG_IsOK(res2)) {
28408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28409 }
28410 if (!argp2) {
28411 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28412 }
28413 arg2 = reinterpret_cast< wxEvent * >(argp2);
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 wxPostEvent(arg1,*arg2);
28417 wxPyEndAllowThreads(__tstate);
28418 if (PyErr_Occurred()) SWIG_fail;
28419 }
28420 resultobj = SWIG_Py_Void();
28421 return resultobj;
28422 fail:
28423 return NULL;
28424 }
28425
28426
28427 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28428 PyObject *resultobj = 0;
28429
28430 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28431 {
28432 PyThreadState* __tstate = wxPyBeginAllowThreads();
28433 wxApp_CleanUp();
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 resultobj = SWIG_Py_Void();
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28445 PyObject *resultobj = 0;
28446 wxPyApp *result = 0 ;
28447
28448 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28449 {
28450 PyThreadState* __tstate = wxPyBeginAllowThreads();
28451 result = (wxPyApp *)wxPyGetApp();
28452 wxPyEndAllowThreads(__tstate);
28453 if (PyErr_Occurred()) SWIG_fail;
28454 }
28455 {
28456 resultobj = wxPyMake_wxObject(result, 0);
28457 }
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28465 PyObject *resultobj = 0;
28466 char *arg1 = (char *) 0 ;
28467 int res1 ;
28468 char *buf1 = 0 ;
28469 int alloc1 = 0 ;
28470 PyObject * obj0 = 0 ;
28471 char * kwnames[] = {
28472 (char *) "encoding", NULL
28473 };
28474
28475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28476 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28477 if (!SWIG_IsOK(res1)) {
28478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28479 }
28480 arg1 = buf1;
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 wxSetDefaultPyEncoding((char const *)arg1);
28484 wxPyEndAllowThreads(__tstate);
28485 if (PyErr_Occurred()) SWIG_fail;
28486 }
28487 resultobj = SWIG_Py_Void();
28488 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28489 return resultobj;
28490 fail:
28491 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28492 return NULL;
28493 }
28494
28495
28496 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28497 PyObject *resultobj = 0;
28498 char *result = 0 ;
28499
28500 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28501 {
28502 PyThreadState* __tstate = wxPyBeginAllowThreads();
28503 result = (char *)wxGetDefaultPyEncoding();
28504 wxPyEndAllowThreads(__tstate);
28505 if (PyErr_Occurred()) SWIG_fail;
28506 }
28507 resultobj = SWIG_FromCharPtr(result);
28508 return resultobj;
28509 fail:
28510 return NULL;
28511 }
28512
28513
28514 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28515 PyObject *resultobj = 0;
28516 wxEventLoop *result = 0 ;
28517
28518 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28519 {
28520 PyThreadState* __tstate = wxPyBeginAllowThreads();
28521 result = (wxEventLoop *)new wxEventLoop();
28522 wxPyEndAllowThreads(__tstate);
28523 if (PyErr_Occurred()) SWIG_fail;
28524 }
28525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28526 return resultobj;
28527 fail:
28528 return NULL;
28529 }
28530
28531
28532 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28533 PyObject *resultobj = 0;
28534 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28535 void *argp1 = 0 ;
28536 int res1 = 0 ;
28537 PyObject *swig_obj[1] ;
28538
28539 if (!args) SWIG_fail;
28540 swig_obj[0] = args;
28541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28542 if (!SWIG_IsOK(res1)) {
28543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28544 }
28545 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28546 {
28547 PyThreadState* __tstate = wxPyBeginAllowThreads();
28548 delete arg1;
28549
28550 wxPyEndAllowThreads(__tstate);
28551 if (PyErr_Occurred()) SWIG_fail;
28552 }
28553 resultobj = SWIG_Py_Void();
28554 return resultobj;
28555 fail:
28556 return NULL;
28557 }
28558
28559
28560 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28561 PyObject *resultobj = 0;
28562 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28563 int result;
28564 void *argp1 = 0 ;
28565 int res1 = 0 ;
28566 PyObject *swig_obj[1] ;
28567
28568 if (!args) SWIG_fail;
28569 swig_obj[0] = args;
28570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28571 if (!SWIG_IsOK(res1)) {
28572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28573 }
28574 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = (int)(arg1)->Run();
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 resultobj = SWIG_From_int(static_cast< int >(result));
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28589 PyObject *resultobj = 0;
28590 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28591 int arg2 = (int) 0 ;
28592 void *argp1 = 0 ;
28593 int res1 = 0 ;
28594 int val2 ;
28595 int ecode2 = 0 ;
28596 PyObject * obj0 = 0 ;
28597 PyObject * obj1 = 0 ;
28598 char * kwnames[] = {
28599 (char *) "self",(char *) "rc", NULL
28600 };
28601
28602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28604 if (!SWIG_IsOK(res1)) {
28605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28606 }
28607 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28608 if (obj1) {
28609 ecode2 = SWIG_AsVal_int(obj1, &val2);
28610 if (!SWIG_IsOK(ecode2)) {
28611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28612 }
28613 arg2 = static_cast< int >(val2);
28614 }
28615 {
28616 PyThreadState* __tstate = wxPyBeginAllowThreads();
28617 (arg1)->Exit(arg2);
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 resultobj = SWIG_Py_Void();
28622 return resultobj;
28623 fail:
28624 return NULL;
28625 }
28626
28627
28628 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28629 PyObject *resultobj = 0;
28630 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28631 bool result;
28632 void *argp1 = 0 ;
28633 int res1 = 0 ;
28634 PyObject *swig_obj[1] ;
28635
28636 if (!args) SWIG_fail;
28637 swig_obj[0] = args;
28638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28639 if (!SWIG_IsOK(res1)) {
28640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28641 }
28642 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28643 {
28644 PyThreadState* __tstate = wxPyBeginAllowThreads();
28645 result = (bool)((wxEventLoop const *)arg1)->Pending();
28646 wxPyEndAllowThreads(__tstate);
28647 if (PyErr_Occurred()) SWIG_fail;
28648 }
28649 {
28650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28651 }
28652 return resultobj;
28653 fail:
28654 return NULL;
28655 }
28656
28657
28658 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28659 PyObject *resultobj = 0;
28660 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28661 bool result;
28662 void *argp1 = 0 ;
28663 int res1 = 0 ;
28664 PyObject *swig_obj[1] ;
28665
28666 if (!args) SWIG_fail;
28667 swig_obj[0] = args;
28668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28669 if (!SWIG_IsOK(res1)) {
28670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28671 }
28672 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28673 {
28674 PyThreadState* __tstate = wxPyBeginAllowThreads();
28675 result = (bool)(arg1)->Dispatch();
28676 wxPyEndAllowThreads(__tstate);
28677 if (PyErr_Occurred()) SWIG_fail;
28678 }
28679 {
28680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28681 }
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689 PyObject *resultobj = 0;
28690 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28691 bool result;
28692 void *argp1 = 0 ;
28693 int res1 = 0 ;
28694 PyObject *swig_obj[1] ;
28695
28696 if (!args) SWIG_fail;
28697 swig_obj[0] = args;
28698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28699 if (!SWIG_IsOK(res1)) {
28700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28701 }
28702 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28703 {
28704 PyThreadState* __tstate = wxPyBeginAllowThreads();
28705 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 {
28710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28711 }
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28719 PyObject *resultobj = 0;
28720 wxEventLoop *result = 0 ;
28721
28722 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 result = (wxEventLoop *)wxEventLoop::GetActive();
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28737 PyObject *resultobj = 0;
28738 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28739 void *argp1 = 0 ;
28740 int res1 = 0 ;
28741 PyObject * obj0 = 0 ;
28742 char * kwnames[] = {
28743 (char *) "loop", NULL
28744 };
28745
28746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28748 if (!SWIG_IsOK(res1)) {
28749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28750 }
28751 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28752 {
28753 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 wxEventLoop::SetActive(arg1);
28755 wxPyEndAllowThreads(__tstate);
28756 if (PyErr_Occurred()) SWIG_fail;
28757 }
28758 resultobj = SWIG_Py_Void();
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28766 PyObject *obj;
28767 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28768 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28769 return SWIG_Py_Void();
28770 }
28771
28772 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28773 return SWIG_Python_InitShadowInstance(args);
28774 }
28775
28776 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28777 PyObject *resultobj = 0;
28778 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28779 wxEventLoopActivator *result = 0 ;
28780 void *argp1 = 0 ;
28781 int res1 = 0 ;
28782 PyObject * obj0 = 0 ;
28783 char * kwnames[] = {
28784 (char *) "evtLoop", NULL
28785 };
28786
28787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28789 if (!SWIG_IsOK(res1)) {
28790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28791 }
28792 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28807 PyObject *resultobj = 0;
28808 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28809 void *argp1 = 0 ;
28810 int res1 = 0 ;
28811 PyObject *swig_obj[1] ;
28812
28813 if (!args) SWIG_fail;
28814 swig_obj[0] = args;
28815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28816 if (!SWIG_IsOK(res1)) {
28817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28818 }
28819 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28820 {
28821 PyThreadState* __tstate = wxPyBeginAllowThreads();
28822 delete arg1;
28823
28824 wxPyEndAllowThreads(__tstate);
28825 if (PyErr_Occurred()) SWIG_fail;
28826 }
28827 resultobj = SWIG_Py_Void();
28828 return resultobj;
28829 fail:
28830 return NULL;
28831 }
28832
28833
28834 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28835 PyObject *obj;
28836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28837 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28838 return SWIG_Py_Void();
28839 }
28840
28841 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28842 return SWIG_Python_InitShadowInstance(args);
28843 }
28844
28845 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28846 PyObject *resultobj = 0;
28847 int arg1 = (int) 0 ;
28848 int arg2 = (int) 0 ;
28849 int arg3 = (int) 0 ;
28850 wxAcceleratorEntry *result = 0 ;
28851 int val1 ;
28852 int ecode1 = 0 ;
28853 int val2 ;
28854 int ecode2 = 0 ;
28855 int val3 ;
28856 int ecode3 = 0 ;
28857 PyObject * obj0 = 0 ;
28858 PyObject * obj1 = 0 ;
28859 PyObject * obj2 = 0 ;
28860 char * kwnames[] = {
28861 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28862 };
28863
28864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28865 if (obj0) {
28866 ecode1 = SWIG_AsVal_int(obj0, &val1);
28867 if (!SWIG_IsOK(ecode1)) {
28868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28869 }
28870 arg1 = static_cast< int >(val1);
28871 }
28872 if (obj1) {
28873 ecode2 = SWIG_AsVal_int(obj1, &val2);
28874 if (!SWIG_IsOK(ecode2)) {
28875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28876 }
28877 arg2 = static_cast< int >(val2);
28878 }
28879 if (obj2) {
28880 ecode3 = SWIG_AsVal_int(obj2, &val3);
28881 if (!SWIG_IsOK(ecode3)) {
28882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28883 }
28884 arg3 = static_cast< int >(val3);
28885 }
28886 {
28887 PyThreadState* __tstate = wxPyBeginAllowThreads();
28888 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28889 wxPyEndAllowThreads(__tstate);
28890 if (PyErr_Occurred()) SWIG_fail;
28891 }
28892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28893 return resultobj;
28894 fail:
28895 return NULL;
28896 }
28897
28898
28899 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28900 PyObject *resultobj = 0;
28901 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28902 void *argp1 = 0 ;
28903 int res1 = 0 ;
28904 PyObject *swig_obj[1] ;
28905
28906 if (!args) SWIG_fail;
28907 swig_obj[0] = args;
28908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28909 if (!SWIG_IsOK(res1)) {
28910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28911 }
28912 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28913 {
28914 PyThreadState* __tstate = wxPyBeginAllowThreads();
28915 delete arg1;
28916
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 resultobj = SWIG_Py_Void();
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28928 PyObject *resultobj = 0;
28929 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28930 int arg2 ;
28931 int arg3 ;
28932 int arg4 ;
28933 void *argp1 = 0 ;
28934 int res1 = 0 ;
28935 int val2 ;
28936 int ecode2 = 0 ;
28937 int val3 ;
28938 int ecode3 = 0 ;
28939 int val4 ;
28940 int ecode4 = 0 ;
28941 PyObject * obj0 = 0 ;
28942 PyObject * obj1 = 0 ;
28943 PyObject * obj2 = 0 ;
28944 PyObject * obj3 = 0 ;
28945 char * kwnames[] = {
28946 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28947 };
28948
28949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28951 if (!SWIG_IsOK(res1)) {
28952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28953 }
28954 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28955 ecode2 = SWIG_AsVal_int(obj1, &val2);
28956 if (!SWIG_IsOK(ecode2)) {
28957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28958 }
28959 arg2 = static_cast< int >(val2);
28960 ecode3 = SWIG_AsVal_int(obj2, &val3);
28961 if (!SWIG_IsOK(ecode3)) {
28962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28963 }
28964 arg3 = static_cast< int >(val3);
28965 ecode4 = SWIG_AsVal_int(obj3, &val4);
28966 if (!SWIG_IsOK(ecode4)) {
28967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28968 }
28969 arg4 = static_cast< int >(val4);
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 (arg1)->Set(arg2,arg3,arg4);
28973 wxPyEndAllowThreads(__tstate);
28974 if (PyErr_Occurred()) SWIG_fail;
28975 }
28976 resultobj = SWIG_Py_Void();
28977 return resultobj;
28978 fail:
28979 return NULL;
28980 }
28981
28982
28983 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28984 PyObject *resultobj = 0;
28985 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28986 int result;
28987 void *argp1 = 0 ;
28988 int res1 = 0 ;
28989 PyObject *swig_obj[1] ;
28990
28991 if (!args) SWIG_fail;
28992 swig_obj[0] = args;
28993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28994 if (!SWIG_IsOK(res1)) {
28995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28996 }
28997 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28998 {
28999 PyThreadState* __tstate = wxPyBeginAllowThreads();
29000 result = (int)(arg1)->GetFlags();
29001 wxPyEndAllowThreads(__tstate);
29002 if (PyErr_Occurred()) SWIG_fail;
29003 }
29004 resultobj = SWIG_From_int(static_cast< int >(result));
29005 return resultobj;
29006 fail:
29007 return NULL;
29008 }
29009
29010
29011 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29012 PyObject *resultobj = 0;
29013 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29014 int result;
29015 void *argp1 = 0 ;
29016 int res1 = 0 ;
29017 PyObject *swig_obj[1] ;
29018
29019 if (!args) SWIG_fail;
29020 swig_obj[0] = args;
29021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29022 if (!SWIG_IsOK(res1)) {
29023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29024 }
29025 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29026 {
29027 PyThreadState* __tstate = wxPyBeginAllowThreads();
29028 result = (int)(arg1)->GetKeyCode();
29029 wxPyEndAllowThreads(__tstate);
29030 if (PyErr_Occurred()) SWIG_fail;
29031 }
29032 resultobj = SWIG_From_int(static_cast< int >(result));
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29040 PyObject *resultobj = 0;
29041 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29042 int result;
29043 void *argp1 = 0 ;
29044 int res1 = 0 ;
29045 PyObject *swig_obj[1] ;
29046
29047 if (!args) SWIG_fail;
29048 swig_obj[0] = args;
29049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29050 if (!SWIG_IsOK(res1)) {
29051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29052 }
29053 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29054 {
29055 PyThreadState* __tstate = wxPyBeginAllowThreads();
29056 result = (int)(arg1)->GetCommand();
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 resultobj = SWIG_From_int(static_cast< int >(result));
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29068 PyObject *obj;
29069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29070 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29071 return SWIG_Py_Void();
29072 }
29073
29074 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29075 return SWIG_Python_InitShadowInstance(args);
29076 }
29077
29078 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29079 PyObject *resultobj = 0;
29080 int arg1 ;
29081 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29082 wxAcceleratorTable *result = 0 ;
29083 PyObject * obj0 = 0 ;
29084 char * kwnames[] = {
29085 (char *) "n", NULL
29086 };
29087
29088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29089 {
29090 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29091 if (arg2) arg1 = PyList_Size(obj0);
29092 else arg1 = 0;
29093 }
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 PyObject *resultobj = 0;
29109 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29110 void *argp1 = 0 ;
29111 int res1 = 0 ;
29112 PyObject *swig_obj[1] ;
29113
29114 if (!args) SWIG_fail;
29115 swig_obj[0] = args;
29116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29117 if (!SWIG_IsOK(res1)) {
29118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29119 }
29120 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29121 {
29122 PyThreadState* __tstate = wxPyBeginAllowThreads();
29123 delete arg1;
29124
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 resultobj = SWIG_Py_Void();
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29136 PyObject *resultobj = 0;
29137 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29138 bool result;
29139 void *argp1 = 0 ;
29140 int res1 = 0 ;
29141 PyObject *swig_obj[1] ;
29142
29143 if (!args) SWIG_fail;
29144 swig_obj[0] = args;
29145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29146 if (!SWIG_IsOK(res1)) {
29147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29148 }
29149 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 {
29157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29158 }
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29166 PyObject *obj;
29167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29168 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29169 return SWIG_Py_Void();
29170 }
29171
29172 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29173 return SWIG_Python_InitShadowInstance(args);
29174 }
29175
29176 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29177 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29178 return 1;
29179 }
29180
29181
29182 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29183 PyObject *pyobj = 0;
29184
29185 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29186 return pyobj;
29187 }
29188
29189
29190 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29191 PyObject *resultobj = 0;
29192 wxString *arg1 = 0 ;
29193 wxAcceleratorEntry *result = 0 ;
29194 bool temp1 = false ;
29195 PyObject * obj0 = 0 ;
29196 char * kwnames[] = {
29197 (char *) "label", NULL
29198 };
29199
29200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29201 {
29202 arg1 = wxString_in_helper(obj0);
29203 if (arg1 == NULL) SWIG_fail;
29204 temp1 = true;
29205 }
29206 {
29207 PyThreadState* __tstate = wxPyBeginAllowThreads();
29208 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29209 wxPyEndAllowThreads(__tstate);
29210 if (PyErr_Occurred()) SWIG_fail;
29211 }
29212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29213 {
29214 if (temp1)
29215 delete arg1;
29216 }
29217 return resultobj;
29218 fail:
29219 {
29220 if (temp1)
29221 delete arg1;
29222 }
29223 return NULL;
29224 }
29225
29226
29227 SWIGINTERN int PanelNameStr_set(PyObject *) {
29228 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29229 return 1;
29230 }
29231
29232
29233 SWIGINTERN PyObject *PanelNameStr_get(void) {
29234 PyObject *pyobj = 0;
29235
29236 {
29237 #if wxUSE_UNICODE
29238 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29239 #else
29240 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29241 #endif
29242 }
29243 return pyobj;
29244 }
29245
29246
29247 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29248 PyObject *resultobj = 0;
29249 wxVisualAttributes *result = 0 ;
29250
29251 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29252 {
29253 PyThreadState* __tstate = wxPyBeginAllowThreads();
29254 result = (wxVisualAttributes *)new_wxVisualAttributes();
29255 wxPyEndAllowThreads(__tstate);
29256 if (PyErr_Occurred()) SWIG_fail;
29257 }
29258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29259 return resultobj;
29260 fail:
29261 return NULL;
29262 }
29263
29264
29265 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29266 PyObject *resultobj = 0;
29267 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29268 void *argp1 = 0 ;
29269 int res1 = 0 ;
29270 PyObject *swig_obj[1] ;
29271
29272 if (!args) SWIG_fail;
29273 swig_obj[0] = args;
29274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29275 if (!SWIG_IsOK(res1)) {
29276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29277 }
29278 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29279 {
29280 PyThreadState* __tstate = wxPyBeginAllowThreads();
29281 delete_wxVisualAttributes(arg1);
29282
29283 wxPyEndAllowThreads(__tstate);
29284 if (PyErr_Occurred()) SWIG_fail;
29285 }
29286 resultobj = SWIG_Py_Void();
29287 return resultobj;
29288 fail:
29289 return NULL;
29290 }
29291
29292
29293 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29294 PyObject *resultobj = 0;
29295 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29296 wxFont *arg2 = (wxFont *) 0 ;
29297 void *argp1 = 0 ;
29298 int res1 = 0 ;
29299 void *argp2 = 0 ;
29300 int res2 = 0 ;
29301 PyObject *swig_obj[2] ;
29302
29303 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29305 if (!SWIG_IsOK(res1)) {
29306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29307 }
29308 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29309 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29310 if (!SWIG_IsOK(res2)) {
29311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29312 }
29313 arg2 = reinterpret_cast< wxFont * >(argp2);
29314 if (arg1) (arg1)->font = *arg2;
29315
29316 resultobj = SWIG_Py_Void();
29317 return resultobj;
29318 fail:
29319 return NULL;
29320 }
29321
29322
29323 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29324 PyObject *resultobj = 0;
29325 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29326 wxFont *result = 0 ;
29327 void *argp1 = 0 ;
29328 int res1 = 0 ;
29329 PyObject *swig_obj[1] ;
29330
29331 if (!args) SWIG_fail;
29332 swig_obj[0] = args;
29333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29334 if (!SWIG_IsOK(res1)) {
29335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29336 }
29337 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29338 result = (wxFont *)& ((arg1)->font);
29339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29347 PyObject *resultobj = 0;
29348 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29349 wxColour *arg2 = (wxColour *) 0 ;
29350 void *argp1 = 0 ;
29351 int res1 = 0 ;
29352 void *argp2 = 0 ;
29353 int res2 = 0 ;
29354 PyObject *swig_obj[2] ;
29355
29356 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29358 if (!SWIG_IsOK(res1)) {
29359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29360 }
29361 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29362 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29363 if (!SWIG_IsOK(res2)) {
29364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29365 }
29366 arg2 = reinterpret_cast< wxColour * >(argp2);
29367 if (arg1) (arg1)->colFg = *arg2;
29368
29369 resultobj = SWIG_Py_Void();
29370 return resultobj;
29371 fail:
29372 return NULL;
29373 }
29374
29375
29376 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29377 PyObject *resultobj = 0;
29378 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29379 wxColour *result = 0 ;
29380 void *argp1 = 0 ;
29381 int res1 = 0 ;
29382 PyObject *swig_obj[1] ;
29383
29384 if (!args) SWIG_fail;
29385 swig_obj[0] = args;
29386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29387 if (!SWIG_IsOK(res1)) {
29388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29389 }
29390 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29391 result = (wxColour *)& ((arg1)->colFg);
29392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29393 return resultobj;
29394 fail:
29395 return NULL;
29396 }
29397
29398
29399 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29400 PyObject *resultobj = 0;
29401 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29402 wxColour *arg2 = (wxColour *) 0 ;
29403 void *argp1 = 0 ;
29404 int res1 = 0 ;
29405 void *argp2 = 0 ;
29406 int res2 = 0 ;
29407 PyObject *swig_obj[2] ;
29408
29409 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29411 if (!SWIG_IsOK(res1)) {
29412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29413 }
29414 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29415 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29416 if (!SWIG_IsOK(res2)) {
29417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29418 }
29419 arg2 = reinterpret_cast< wxColour * >(argp2);
29420 if (arg1) (arg1)->colBg = *arg2;
29421
29422 resultobj = SWIG_Py_Void();
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29430 PyObject *resultobj = 0;
29431 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29432 wxColour *result = 0 ;
29433 void *argp1 = 0 ;
29434 int res1 = 0 ;
29435 PyObject *swig_obj[1] ;
29436
29437 if (!args) SWIG_fail;
29438 swig_obj[0] = args;
29439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29440 if (!SWIG_IsOK(res1)) {
29441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29442 }
29443 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29444 result = (wxColour *)& ((arg1)->colBg);
29445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29446 return resultobj;
29447 fail:
29448 return NULL;
29449 }
29450
29451
29452 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29453 PyObject *obj;
29454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29455 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29456 return SWIG_Py_Void();
29457 }
29458
29459 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29460 return SWIG_Python_InitShadowInstance(args);
29461 }
29462
29463 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29464 PyObject *resultobj = 0;
29465 wxWindow *arg1 = (wxWindow *) 0 ;
29466 int arg2 = (int) (int)-1 ;
29467 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29468 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29469 wxSize const &arg4_defvalue = wxDefaultSize ;
29470 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29471 long arg5 = (long) 0 ;
29472 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29473 wxString *arg6 = (wxString *) &arg6_defvalue ;
29474 wxWindow *result = 0 ;
29475 void *argp1 = 0 ;
29476 int res1 = 0 ;
29477 int val2 ;
29478 int ecode2 = 0 ;
29479 wxPoint temp3 ;
29480 wxSize temp4 ;
29481 long val5 ;
29482 int ecode5 = 0 ;
29483 bool temp6 = false ;
29484 PyObject * obj0 = 0 ;
29485 PyObject * obj1 = 0 ;
29486 PyObject * obj2 = 0 ;
29487 PyObject * obj3 = 0 ;
29488 PyObject * obj4 = 0 ;
29489 PyObject * obj5 = 0 ;
29490 char * kwnames[] = {
29491 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29492 };
29493
29494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29496 if (!SWIG_IsOK(res1)) {
29497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29498 }
29499 arg1 = reinterpret_cast< wxWindow * >(argp1);
29500 if (obj1) {
29501 ecode2 = SWIG_AsVal_int(obj1, &val2);
29502 if (!SWIG_IsOK(ecode2)) {
29503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29504 }
29505 arg2 = static_cast< int >(val2);
29506 }
29507 if (obj2) {
29508 {
29509 arg3 = &temp3;
29510 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29511 }
29512 }
29513 if (obj3) {
29514 {
29515 arg4 = &temp4;
29516 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29517 }
29518 }
29519 if (obj4) {
29520 ecode5 = SWIG_AsVal_long(obj4, &val5);
29521 if (!SWIG_IsOK(ecode5)) {
29522 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29523 }
29524 arg5 = static_cast< long >(val5);
29525 }
29526 if (obj5) {
29527 {
29528 arg6 = wxString_in_helper(obj5);
29529 if (arg6 == NULL) SWIG_fail;
29530 temp6 = true;
29531 }
29532 }
29533 {
29534 if (!wxPyCheckForApp()) SWIG_fail;
29535 PyThreadState* __tstate = wxPyBeginAllowThreads();
29536 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29537 wxPyEndAllowThreads(__tstate);
29538 if (PyErr_Occurred()) SWIG_fail;
29539 }
29540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29541 {
29542 if (temp6)
29543 delete arg6;
29544 }
29545 return resultobj;
29546 fail:
29547 {
29548 if (temp6)
29549 delete arg6;
29550 }
29551 return NULL;
29552 }
29553
29554
29555 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29556 PyObject *resultobj = 0;
29557 wxWindow *result = 0 ;
29558
29559 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29560 {
29561 if (!wxPyCheckForApp()) SWIG_fail;
29562 PyThreadState* __tstate = wxPyBeginAllowThreads();
29563 result = (wxWindow *)new wxWindow();
29564 wxPyEndAllowThreads(__tstate);
29565 if (PyErr_Occurred()) SWIG_fail;
29566 }
29567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29568 return resultobj;
29569 fail:
29570 return NULL;
29571 }
29572
29573
29574 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29575 PyObject *resultobj = 0;
29576 wxWindow *arg1 = (wxWindow *) 0 ;
29577 wxWindow *arg2 = (wxWindow *) 0 ;
29578 int arg3 = (int) (int)-1 ;
29579 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29580 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29581 wxSize const &arg5_defvalue = wxDefaultSize ;
29582 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29583 long arg6 = (long) 0 ;
29584 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29585 wxString *arg7 = (wxString *) &arg7_defvalue ;
29586 bool result;
29587 void *argp1 = 0 ;
29588 int res1 = 0 ;
29589 void *argp2 = 0 ;
29590 int res2 = 0 ;
29591 int val3 ;
29592 int ecode3 = 0 ;
29593 wxPoint temp4 ;
29594 wxSize temp5 ;
29595 long val6 ;
29596 int ecode6 = 0 ;
29597 bool temp7 = false ;
29598 PyObject * obj0 = 0 ;
29599 PyObject * obj1 = 0 ;
29600 PyObject * obj2 = 0 ;
29601 PyObject * obj3 = 0 ;
29602 PyObject * obj4 = 0 ;
29603 PyObject * obj5 = 0 ;
29604 PyObject * obj6 = 0 ;
29605 char * kwnames[] = {
29606 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29607 };
29608
29609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29611 if (!SWIG_IsOK(res1)) {
29612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29613 }
29614 arg1 = reinterpret_cast< wxWindow * >(argp1);
29615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29616 if (!SWIG_IsOK(res2)) {
29617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29618 }
29619 arg2 = reinterpret_cast< wxWindow * >(argp2);
29620 if (obj2) {
29621 ecode3 = SWIG_AsVal_int(obj2, &val3);
29622 if (!SWIG_IsOK(ecode3)) {
29623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29624 }
29625 arg3 = static_cast< int >(val3);
29626 }
29627 if (obj3) {
29628 {
29629 arg4 = &temp4;
29630 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29631 }
29632 }
29633 if (obj4) {
29634 {
29635 arg5 = &temp5;
29636 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29637 }
29638 }
29639 if (obj5) {
29640 ecode6 = SWIG_AsVal_long(obj5, &val6);
29641 if (!SWIG_IsOK(ecode6)) {
29642 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29643 }
29644 arg6 = static_cast< long >(val6);
29645 }
29646 if (obj6) {
29647 {
29648 arg7 = wxString_in_helper(obj6);
29649 if (arg7 == NULL) SWIG_fail;
29650 temp7 = true;
29651 }
29652 }
29653 {
29654 PyThreadState* __tstate = wxPyBeginAllowThreads();
29655 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29656 wxPyEndAllowThreads(__tstate);
29657 if (PyErr_Occurred()) SWIG_fail;
29658 }
29659 {
29660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29661 }
29662 {
29663 if (temp7)
29664 delete arg7;
29665 }
29666 return resultobj;
29667 fail:
29668 {
29669 if (temp7)
29670 delete arg7;
29671 }
29672 return NULL;
29673 }
29674
29675
29676 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29677 PyObject *resultobj = 0;
29678 wxWindow *arg1 = (wxWindow *) 0 ;
29679 bool arg2 = (bool) false ;
29680 bool result;
29681 void *argp1 = 0 ;
29682 int res1 = 0 ;
29683 bool val2 ;
29684 int ecode2 = 0 ;
29685 PyObject * obj0 = 0 ;
29686 PyObject * obj1 = 0 ;
29687 char * kwnames[] = {
29688 (char *) "self",(char *) "force", NULL
29689 };
29690
29691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29693 if (!SWIG_IsOK(res1)) {
29694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29695 }
29696 arg1 = reinterpret_cast< wxWindow * >(argp1);
29697 if (obj1) {
29698 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29699 if (!SWIG_IsOK(ecode2)) {
29700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29701 }
29702 arg2 = static_cast< bool >(val2);
29703 }
29704 {
29705 PyThreadState* __tstate = wxPyBeginAllowThreads();
29706 result = (bool)(arg1)->Close(arg2);
29707 wxPyEndAllowThreads(__tstate);
29708 if (PyErr_Occurred()) SWIG_fail;
29709 }
29710 {
29711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29712 }
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29720 PyObject *resultobj = 0;
29721 wxWindow *arg1 = (wxWindow *) 0 ;
29722 bool result;
29723 void *argp1 = 0 ;
29724 int res1 = 0 ;
29725 PyObject *swig_obj[1] ;
29726
29727 if (!args) SWIG_fail;
29728 swig_obj[0] = args;
29729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29730 if (!SWIG_IsOK(res1)) {
29731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29732 }
29733 arg1 = reinterpret_cast< wxWindow * >(argp1);
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 result = (bool)(arg1)->Destroy();
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 {
29741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29742 }
29743 return resultobj;
29744 fail:
29745 return NULL;
29746 }
29747
29748
29749 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29750 PyObject *resultobj = 0;
29751 wxWindow *arg1 = (wxWindow *) 0 ;
29752 bool result;
29753 void *argp1 = 0 ;
29754 int res1 = 0 ;
29755 PyObject *swig_obj[1] ;
29756
29757 if (!args) SWIG_fail;
29758 swig_obj[0] = args;
29759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29760 if (!SWIG_IsOK(res1)) {
29761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29762 }
29763 arg1 = reinterpret_cast< wxWindow * >(argp1);
29764 {
29765 PyThreadState* __tstate = wxPyBeginAllowThreads();
29766 result = (bool)(arg1)->DestroyChildren();
29767 wxPyEndAllowThreads(__tstate);
29768 if (PyErr_Occurred()) SWIG_fail;
29769 }
29770 {
29771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29772 }
29773 return resultobj;
29774 fail:
29775 return NULL;
29776 }
29777
29778
29779 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29780 PyObject *resultobj = 0;
29781 wxWindow *arg1 = (wxWindow *) 0 ;
29782 bool result;
29783 void *argp1 = 0 ;
29784 int res1 = 0 ;
29785 PyObject *swig_obj[1] ;
29786
29787 if (!args) SWIG_fail;
29788 swig_obj[0] = args;
29789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29790 if (!SWIG_IsOK(res1)) {
29791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29792 }
29793 arg1 = reinterpret_cast< wxWindow * >(argp1);
29794 {
29795 PyThreadState* __tstate = wxPyBeginAllowThreads();
29796 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29797 wxPyEndAllowThreads(__tstate);
29798 if (PyErr_Occurred()) SWIG_fail;
29799 }
29800 {
29801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29802 }
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29810 PyObject *resultobj = 0;
29811 wxWindow *arg1 = (wxWindow *) 0 ;
29812 wxString *arg2 = 0 ;
29813 void *argp1 = 0 ;
29814 int res1 = 0 ;
29815 bool temp2 = false ;
29816 PyObject * obj0 = 0 ;
29817 PyObject * obj1 = 0 ;
29818 char * kwnames[] = {
29819 (char *) "self",(char *) "label", NULL
29820 };
29821
29822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29824 if (!SWIG_IsOK(res1)) {
29825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29826 }
29827 arg1 = reinterpret_cast< wxWindow * >(argp1);
29828 {
29829 arg2 = wxString_in_helper(obj1);
29830 if (arg2 == NULL) SWIG_fail;
29831 temp2 = true;
29832 }
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 (arg1)->SetLabel((wxString const &)*arg2);
29836 wxPyEndAllowThreads(__tstate);
29837 if (PyErr_Occurred()) SWIG_fail;
29838 }
29839 resultobj = SWIG_Py_Void();
29840 {
29841 if (temp2)
29842 delete arg2;
29843 }
29844 return resultobj;
29845 fail:
29846 {
29847 if (temp2)
29848 delete arg2;
29849 }
29850 return NULL;
29851 }
29852
29853
29854 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29855 PyObject *resultobj = 0;
29856 wxWindow *arg1 = (wxWindow *) 0 ;
29857 wxString result;
29858 void *argp1 = 0 ;
29859 int res1 = 0 ;
29860 PyObject *swig_obj[1] ;
29861
29862 if (!args) SWIG_fail;
29863 swig_obj[0] = args;
29864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29865 if (!SWIG_IsOK(res1)) {
29866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29867 }
29868 arg1 = reinterpret_cast< wxWindow * >(argp1);
29869 {
29870 PyThreadState* __tstate = wxPyBeginAllowThreads();
29871 result = ((wxWindow const *)arg1)->GetLabel();
29872 wxPyEndAllowThreads(__tstate);
29873 if (PyErr_Occurred()) SWIG_fail;
29874 }
29875 {
29876 #if wxUSE_UNICODE
29877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29878 #else
29879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29880 #endif
29881 }
29882 return resultobj;
29883 fail:
29884 return NULL;
29885 }
29886
29887
29888 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29889 PyObject *resultobj = 0;
29890 wxWindow *arg1 = (wxWindow *) 0 ;
29891 wxString *arg2 = 0 ;
29892 void *argp1 = 0 ;
29893 int res1 = 0 ;
29894 bool temp2 = false ;
29895 PyObject * obj0 = 0 ;
29896 PyObject * obj1 = 0 ;
29897 char * kwnames[] = {
29898 (char *) "self",(char *) "name", NULL
29899 };
29900
29901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29903 if (!SWIG_IsOK(res1)) {
29904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29905 }
29906 arg1 = reinterpret_cast< wxWindow * >(argp1);
29907 {
29908 arg2 = wxString_in_helper(obj1);
29909 if (arg2 == NULL) SWIG_fail;
29910 temp2 = true;
29911 }
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 (arg1)->SetName((wxString const &)*arg2);
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 resultobj = SWIG_Py_Void();
29919 {
29920 if (temp2)
29921 delete arg2;
29922 }
29923 return resultobj;
29924 fail:
29925 {
29926 if (temp2)
29927 delete arg2;
29928 }
29929 return NULL;
29930 }
29931
29932
29933 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29934 PyObject *resultobj = 0;
29935 wxWindow *arg1 = (wxWindow *) 0 ;
29936 wxString result;
29937 void *argp1 = 0 ;
29938 int res1 = 0 ;
29939 PyObject *swig_obj[1] ;
29940
29941 if (!args) SWIG_fail;
29942 swig_obj[0] = args;
29943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29944 if (!SWIG_IsOK(res1)) {
29945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29946 }
29947 arg1 = reinterpret_cast< wxWindow * >(argp1);
29948 {
29949 PyThreadState* __tstate = wxPyBeginAllowThreads();
29950 result = ((wxWindow const *)arg1)->GetName();
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 {
29955 #if wxUSE_UNICODE
29956 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29957 #else
29958 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29959 #endif
29960 }
29961 return resultobj;
29962 fail:
29963 return NULL;
29964 }
29965
29966
29967 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29968 PyObject *resultobj = 0;
29969 wxWindow *arg1 = (wxWindow *) 0 ;
29970 wxWindowVariant arg2 ;
29971 void *argp1 = 0 ;
29972 int res1 = 0 ;
29973 int val2 ;
29974 int ecode2 = 0 ;
29975 PyObject * obj0 = 0 ;
29976 PyObject * obj1 = 0 ;
29977 char * kwnames[] = {
29978 (char *) "self",(char *) "variant", NULL
29979 };
29980
29981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29983 if (!SWIG_IsOK(res1)) {
29984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29985 }
29986 arg1 = reinterpret_cast< wxWindow * >(argp1);
29987 ecode2 = SWIG_AsVal_int(obj1, &val2);
29988 if (!SWIG_IsOK(ecode2)) {
29989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29990 }
29991 arg2 = static_cast< wxWindowVariant >(val2);
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 (arg1)->SetWindowVariant(arg2);
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 resultobj = SWIG_Py_Void();
29999 return resultobj;
30000 fail:
30001 return NULL;
30002 }
30003
30004
30005 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30006 PyObject *resultobj = 0;
30007 wxWindow *arg1 = (wxWindow *) 0 ;
30008 wxWindowVariant result;
30009 void *argp1 = 0 ;
30010 int res1 = 0 ;
30011 PyObject *swig_obj[1] ;
30012
30013 if (!args) SWIG_fail;
30014 swig_obj[0] = args;
30015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30016 if (!SWIG_IsOK(res1)) {
30017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30018 }
30019 arg1 = reinterpret_cast< wxWindow * >(argp1);
30020 {
30021 PyThreadState* __tstate = wxPyBeginAllowThreads();
30022 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30023 wxPyEndAllowThreads(__tstate);
30024 if (PyErr_Occurred()) SWIG_fail;
30025 }
30026 resultobj = SWIG_From_int(static_cast< int >(result));
30027 return resultobj;
30028 fail:
30029 return NULL;
30030 }
30031
30032
30033 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30034 PyObject *resultobj = 0;
30035 wxWindow *arg1 = (wxWindow *) 0 ;
30036 int arg2 ;
30037 void *argp1 = 0 ;
30038 int res1 = 0 ;
30039 int val2 ;
30040 int ecode2 = 0 ;
30041 PyObject * obj0 = 0 ;
30042 PyObject * obj1 = 0 ;
30043 char * kwnames[] = {
30044 (char *) "self",(char *) "winid", NULL
30045 };
30046
30047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30049 if (!SWIG_IsOK(res1)) {
30050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30051 }
30052 arg1 = reinterpret_cast< wxWindow * >(argp1);
30053 ecode2 = SWIG_AsVal_int(obj1, &val2);
30054 if (!SWIG_IsOK(ecode2)) {
30055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30056 }
30057 arg2 = static_cast< int >(val2);
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 (arg1)->SetId(arg2);
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 resultobj = SWIG_Py_Void();
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30072 PyObject *resultobj = 0;
30073 wxWindow *arg1 = (wxWindow *) 0 ;
30074 int result;
30075 void *argp1 = 0 ;
30076 int res1 = 0 ;
30077 PyObject *swig_obj[1] ;
30078
30079 if (!args) SWIG_fail;
30080 swig_obj[0] = args;
30081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30082 if (!SWIG_IsOK(res1)) {
30083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30084 }
30085 arg1 = reinterpret_cast< wxWindow * >(argp1);
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 result = (int)((wxWindow const *)arg1)->GetId();
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_From_int(static_cast< int >(result));
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *resultobj = 0;
30101 int result;
30102
30103 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30104 {
30105 PyThreadState* __tstate = wxPyBeginAllowThreads();
30106 result = (int)wxWindow::NewControlId();
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 resultobj = SWIG_From_int(static_cast< int >(result));
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj = 0;
30119 int arg1 ;
30120 int result;
30121 int val1 ;
30122 int ecode1 = 0 ;
30123 PyObject * obj0 = 0 ;
30124 char * kwnames[] = {
30125 (char *) "winid", NULL
30126 };
30127
30128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30129 ecode1 = SWIG_AsVal_int(obj0, &val1);
30130 if (!SWIG_IsOK(ecode1)) {
30131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30132 }
30133 arg1 = static_cast< int >(val1);
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 result = (int)wxWindow::NextControlId(arg1);
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 resultobj = SWIG_From_int(static_cast< int >(result));
30141 return resultobj;
30142 fail:
30143 return NULL;
30144 }
30145
30146
30147 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30148 PyObject *resultobj = 0;
30149 int arg1 ;
30150 int result;
30151 int val1 ;
30152 int ecode1 = 0 ;
30153 PyObject * obj0 = 0 ;
30154 char * kwnames[] = {
30155 (char *) "winid", NULL
30156 };
30157
30158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30159 ecode1 = SWIG_AsVal_int(obj0, &val1);
30160 if (!SWIG_IsOK(ecode1)) {
30161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30162 }
30163 arg1 = static_cast< int >(val1);
30164 {
30165 PyThreadState* __tstate = wxPyBeginAllowThreads();
30166 result = (int)wxWindow::PrevControlId(arg1);
30167 wxPyEndAllowThreads(__tstate);
30168 if (PyErr_Occurred()) SWIG_fail;
30169 }
30170 resultobj = SWIG_From_int(static_cast< int >(result));
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30178 PyObject *resultobj = 0;
30179 wxWindow *arg1 = (wxWindow *) 0 ;
30180 wxSize *arg2 = 0 ;
30181 void *argp1 = 0 ;
30182 int res1 = 0 ;
30183 wxSize temp2 ;
30184 PyObject * obj0 = 0 ;
30185 PyObject * obj1 = 0 ;
30186 char * kwnames[] = {
30187 (char *) "self",(char *) "size", NULL
30188 };
30189
30190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30192 if (!SWIG_IsOK(res1)) {
30193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30194 }
30195 arg1 = reinterpret_cast< wxWindow * >(argp1);
30196 {
30197 arg2 = &temp2;
30198 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30199 }
30200 {
30201 PyThreadState* __tstate = wxPyBeginAllowThreads();
30202 (arg1)->SetSize((wxSize const &)*arg2);
30203 wxPyEndAllowThreads(__tstate);
30204 if (PyErr_Occurred()) SWIG_fail;
30205 }
30206 resultobj = SWIG_Py_Void();
30207 return resultobj;
30208 fail:
30209 return NULL;
30210 }
30211
30212
30213 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30214 PyObject *resultobj = 0;
30215 wxWindow *arg1 = (wxWindow *) 0 ;
30216 int arg2 ;
30217 int arg3 ;
30218 int arg4 ;
30219 int arg5 ;
30220 int arg6 = (int) wxSIZE_AUTO ;
30221 void *argp1 = 0 ;
30222 int res1 = 0 ;
30223 int val2 ;
30224 int ecode2 = 0 ;
30225 int val3 ;
30226 int ecode3 = 0 ;
30227 int val4 ;
30228 int ecode4 = 0 ;
30229 int val5 ;
30230 int ecode5 = 0 ;
30231 int val6 ;
30232 int ecode6 = 0 ;
30233 PyObject * obj0 = 0 ;
30234 PyObject * obj1 = 0 ;
30235 PyObject * obj2 = 0 ;
30236 PyObject * obj3 = 0 ;
30237 PyObject * obj4 = 0 ;
30238 PyObject * obj5 = 0 ;
30239 char * kwnames[] = {
30240 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30241 };
30242
30243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30245 if (!SWIG_IsOK(res1)) {
30246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30247 }
30248 arg1 = reinterpret_cast< wxWindow * >(argp1);
30249 ecode2 = SWIG_AsVal_int(obj1, &val2);
30250 if (!SWIG_IsOK(ecode2)) {
30251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30252 }
30253 arg2 = static_cast< int >(val2);
30254 ecode3 = SWIG_AsVal_int(obj2, &val3);
30255 if (!SWIG_IsOK(ecode3)) {
30256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30257 }
30258 arg3 = static_cast< int >(val3);
30259 ecode4 = SWIG_AsVal_int(obj3, &val4);
30260 if (!SWIG_IsOK(ecode4)) {
30261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30262 }
30263 arg4 = static_cast< int >(val4);
30264 ecode5 = SWIG_AsVal_int(obj4, &val5);
30265 if (!SWIG_IsOK(ecode5)) {
30266 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30267 }
30268 arg5 = static_cast< int >(val5);
30269 if (obj5) {
30270 ecode6 = SWIG_AsVal_int(obj5, &val6);
30271 if (!SWIG_IsOK(ecode6)) {
30272 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30273 }
30274 arg6 = static_cast< int >(val6);
30275 }
30276 {
30277 PyThreadState* __tstate = wxPyBeginAllowThreads();
30278 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30279 wxPyEndAllowThreads(__tstate);
30280 if (PyErr_Occurred()) SWIG_fail;
30281 }
30282 resultobj = SWIG_Py_Void();
30283 return resultobj;
30284 fail:
30285 return NULL;
30286 }
30287
30288
30289 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30290 PyObject *resultobj = 0;
30291 wxWindow *arg1 = (wxWindow *) 0 ;
30292 wxRect *arg2 = 0 ;
30293 int arg3 = (int) wxSIZE_AUTO ;
30294 void *argp1 = 0 ;
30295 int res1 = 0 ;
30296 wxRect temp2 ;
30297 int val3 ;
30298 int ecode3 = 0 ;
30299 PyObject * obj0 = 0 ;
30300 PyObject * obj1 = 0 ;
30301 PyObject * obj2 = 0 ;
30302 char * kwnames[] = {
30303 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30304 };
30305
30306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30308 if (!SWIG_IsOK(res1)) {
30309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30310 }
30311 arg1 = reinterpret_cast< wxWindow * >(argp1);
30312 {
30313 arg2 = &temp2;
30314 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30315 }
30316 if (obj2) {
30317 ecode3 = SWIG_AsVal_int(obj2, &val3);
30318 if (!SWIG_IsOK(ecode3)) {
30319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30320 }
30321 arg3 = static_cast< int >(val3);
30322 }
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 resultobj = SWIG_Py_Void();
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30337 PyObject *resultobj = 0;
30338 wxWindow *arg1 = (wxWindow *) 0 ;
30339 int arg2 ;
30340 int arg3 ;
30341 void *argp1 = 0 ;
30342 int res1 = 0 ;
30343 int val2 ;
30344 int ecode2 = 0 ;
30345 int val3 ;
30346 int ecode3 = 0 ;
30347 PyObject * obj0 = 0 ;
30348 PyObject * obj1 = 0 ;
30349 PyObject * obj2 = 0 ;
30350 char * kwnames[] = {
30351 (char *) "self",(char *) "width",(char *) "height", NULL
30352 };
30353
30354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30356 if (!SWIG_IsOK(res1)) {
30357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30358 }
30359 arg1 = reinterpret_cast< wxWindow * >(argp1);
30360 ecode2 = SWIG_AsVal_int(obj1, &val2);
30361 if (!SWIG_IsOK(ecode2)) {
30362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30363 }
30364 arg2 = static_cast< int >(val2);
30365 ecode3 = SWIG_AsVal_int(obj2, &val3);
30366 if (!SWIG_IsOK(ecode3)) {
30367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30368 }
30369 arg3 = static_cast< int >(val3);
30370 {
30371 PyThreadState* __tstate = wxPyBeginAllowThreads();
30372 (arg1)->SetSize(arg2,arg3);
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 resultobj = SWIG_Py_Void();
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30384 PyObject *resultobj = 0;
30385 wxWindow *arg1 = (wxWindow *) 0 ;
30386 wxPoint *arg2 = 0 ;
30387 int arg3 = (int) wxSIZE_USE_EXISTING ;
30388 void *argp1 = 0 ;
30389 int res1 = 0 ;
30390 wxPoint temp2 ;
30391 int val3 ;
30392 int ecode3 = 0 ;
30393 PyObject * obj0 = 0 ;
30394 PyObject * obj1 = 0 ;
30395 PyObject * obj2 = 0 ;
30396 char * kwnames[] = {
30397 (char *) "self",(char *) "pt",(char *) "flags", NULL
30398 };
30399
30400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30402 if (!SWIG_IsOK(res1)) {
30403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30404 }
30405 arg1 = reinterpret_cast< wxWindow * >(argp1);
30406 {
30407 arg2 = &temp2;
30408 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30409 }
30410 if (obj2) {
30411 ecode3 = SWIG_AsVal_int(obj2, &val3);
30412 if (!SWIG_IsOK(ecode3)) {
30413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30414 }
30415 arg3 = static_cast< int >(val3);
30416 }
30417 {
30418 PyThreadState* __tstate = wxPyBeginAllowThreads();
30419 (arg1)->Move((wxPoint const &)*arg2,arg3);
30420 wxPyEndAllowThreads(__tstate);
30421 if (PyErr_Occurred()) SWIG_fail;
30422 }
30423 resultobj = SWIG_Py_Void();
30424 return resultobj;
30425 fail:
30426 return NULL;
30427 }
30428
30429
30430 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30431 PyObject *resultobj = 0;
30432 wxWindow *arg1 = (wxWindow *) 0 ;
30433 int arg2 ;
30434 int arg3 ;
30435 int arg4 = (int) wxSIZE_USE_EXISTING ;
30436 void *argp1 = 0 ;
30437 int res1 = 0 ;
30438 int val2 ;
30439 int ecode2 = 0 ;
30440 int val3 ;
30441 int ecode3 = 0 ;
30442 int val4 ;
30443 int ecode4 = 0 ;
30444 PyObject * obj0 = 0 ;
30445 PyObject * obj1 = 0 ;
30446 PyObject * obj2 = 0 ;
30447 PyObject * obj3 = 0 ;
30448 char * kwnames[] = {
30449 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30450 };
30451
30452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30454 if (!SWIG_IsOK(res1)) {
30455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30456 }
30457 arg1 = reinterpret_cast< wxWindow * >(argp1);
30458 ecode2 = SWIG_AsVal_int(obj1, &val2);
30459 if (!SWIG_IsOK(ecode2)) {
30460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30461 }
30462 arg2 = static_cast< int >(val2);
30463 ecode3 = SWIG_AsVal_int(obj2, &val3);
30464 if (!SWIG_IsOK(ecode3)) {
30465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30466 }
30467 arg3 = static_cast< int >(val3);
30468 if (obj3) {
30469 ecode4 = SWIG_AsVal_int(obj3, &val4);
30470 if (!SWIG_IsOK(ecode4)) {
30471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30472 }
30473 arg4 = static_cast< int >(val4);
30474 }
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 (arg1)->Move(arg2,arg3,arg4);
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 resultobj = SWIG_Py_Void();
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj = 0;
30490 wxWindow *arg1 = (wxWindow *) 0 ;
30491 wxSize const &arg2_defvalue = wxDefaultSize ;
30492 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30493 void *argp1 = 0 ;
30494 int res1 = 0 ;
30495 wxSize temp2 ;
30496 PyObject * obj0 = 0 ;
30497 PyObject * obj1 = 0 ;
30498 char * kwnames[] = {
30499 (char *) "self",(char *) "size", NULL
30500 };
30501
30502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30504 if (!SWIG_IsOK(res1)) {
30505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30506 }
30507 arg1 = reinterpret_cast< wxWindow * >(argp1);
30508 if (obj1) {
30509 {
30510 arg2 = &temp2;
30511 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30512 }
30513 }
30514 {
30515 PyThreadState* __tstate = wxPyBeginAllowThreads();
30516 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30517 wxPyEndAllowThreads(__tstate);
30518 if (PyErr_Occurred()) SWIG_fail;
30519 }
30520 resultobj = SWIG_Py_Void();
30521 return resultobj;
30522 fail:
30523 return NULL;
30524 }
30525
30526
30527 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30528 PyObject *resultobj = 0;
30529 wxWindow *arg1 = (wxWindow *) 0 ;
30530 void *argp1 = 0 ;
30531 int res1 = 0 ;
30532 PyObject *swig_obj[1] ;
30533
30534 if (!args) SWIG_fail;
30535 swig_obj[0] = args;
30536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30539 }
30540 arg1 = reinterpret_cast< wxWindow * >(argp1);
30541 {
30542 PyThreadState* __tstate = wxPyBeginAllowThreads();
30543 (arg1)->Raise();
30544 wxPyEndAllowThreads(__tstate);
30545 if (PyErr_Occurred()) SWIG_fail;
30546 }
30547 resultobj = SWIG_Py_Void();
30548 return resultobj;
30549 fail:
30550 return NULL;
30551 }
30552
30553
30554 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30555 PyObject *resultobj = 0;
30556 wxWindow *arg1 = (wxWindow *) 0 ;
30557 void *argp1 = 0 ;
30558 int res1 = 0 ;
30559 PyObject *swig_obj[1] ;
30560
30561 if (!args) SWIG_fail;
30562 swig_obj[0] = args;
30563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30564 if (!SWIG_IsOK(res1)) {
30565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30566 }
30567 arg1 = reinterpret_cast< wxWindow * >(argp1);
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 (arg1)->Lower();
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 resultobj = SWIG_Py_Void();
30575 return resultobj;
30576 fail:
30577 return NULL;
30578 }
30579
30580
30581 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30582 PyObject *resultobj = 0;
30583 wxWindow *arg1 = (wxWindow *) 0 ;
30584 wxSize *arg2 = 0 ;
30585 void *argp1 = 0 ;
30586 int res1 = 0 ;
30587 wxSize temp2 ;
30588 PyObject * obj0 = 0 ;
30589 PyObject * obj1 = 0 ;
30590 char * kwnames[] = {
30591 (char *) "self",(char *) "size", NULL
30592 };
30593
30594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30596 if (!SWIG_IsOK(res1)) {
30597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30598 }
30599 arg1 = reinterpret_cast< wxWindow * >(argp1);
30600 {
30601 arg2 = &temp2;
30602 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30603 }
30604 {
30605 PyThreadState* __tstate = wxPyBeginAllowThreads();
30606 (arg1)->SetClientSize((wxSize const &)*arg2);
30607 wxPyEndAllowThreads(__tstate);
30608 if (PyErr_Occurred()) SWIG_fail;
30609 }
30610 resultobj = SWIG_Py_Void();
30611 return resultobj;
30612 fail:
30613 return NULL;
30614 }
30615
30616
30617 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj = 0;
30619 wxWindow *arg1 = (wxWindow *) 0 ;
30620 int arg2 ;
30621 int arg3 ;
30622 void *argp1 = 0 ;
30623 int res1 = 0 ;
30624 int val2 ;
30625 int ecode2 = 0 ;
30626 int val3 ;
30627 int ecode3 = 0 ;
30628 PyObject * obj0 = 0 ;
30629 PyObject * obj1 = 0 ;
30630 PyObject * obj2 = 0 ;
30631 char * kwnames[] = {
30632 (char *) "self",(char *) "width",(char *) "height", NULL
30633 };
30634
30635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30637 if (!SWIG_IsOK(res1)) {
30638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30639 }
30640 arg1 = reinterpret_cast< wxWindow * >(argp1);
30641 ecode2 = SWIG_AsVal_int(obj1, &val2);
30642 if (!SWIG_IsOK(ecode2)) {
30643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30644 }
30645 arg2 = static_cast< int >(val2);
30646 ecode3 = SWIG_AsVal_int(obj2, &val3);
30647 if (!SWIG_IsOK(ecode3)) {
30648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30649 }
30650 arg3 = static_cast< int >(val3);
30651 {
30652 PyThreadState* __tstate = wxPyBeginAllowThreads();
30653 (arg1)->SetClientSize(arg2,arg3);
30654 wxPyEndAllowThreads(__tstate);
30655 if (PyErr_Occurred()) SWIG_fail;
30656 }
30657 resultobj = SWIG_Py_Void();
30658 return resultobj;
30659 fail:
30660 return NULL;
30661 }
30662
30663
30664 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30665 PyObject *resultobj = 0;
30666 wxWindow *arg1 = (wxWindow *) 0 ;
30667 wxRect *arg2 = 0 ;
30668 void *argp1 = 0 ;
30669 int res1 = 0 ;
30670 wxRect temp2 ;
30671 PyObject * obj0 = 0 ;
30672 PyObject * obj1 = 0 ;
30673 char * kwnames[] = {
30674 (char *) "self",(char *) "rect", NULL
30675 };
30676
30677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30679 if (!SWIG_IsOK(res1)) {
30680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30681 }
30682 arg1 = reinterpret_cast< wxWindow * >(argp1);
30683 {
30684 arg2 = &temp2;
30685 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30686 }
30687 {
30688 PyThreadState* __tstate = wxPyBeginAllowThreads();
30689 (arg1)->SetClientSize((wxRect const &)*arg2);
30690 wxPyEndAllowThreads(__tstate);
30691 if (PyErr_Occurred()) SWIG_fail;
30692 }
30693 resultobj = SWIG_Py_Void();
30694 return resultobj;
30695 fail:
30696 return NULL;
30697 }
30698
30699
30700 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30701 PyObject *resultobj = 0;
30702 wxWindow *arg1 = (wxWindow *) 0 ;
30703 wxPoint result;
30704 void *argp1 = 0 ;
30705 int res1 = 0 ;
30706 PyObject *swig_obj[1] ;
30707
30708 if (!args) SWIG_fail;
30709 swig_obj[0] = args;
30710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30711 if (!SWIG_IsOK(res1)) {
30712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30713 }
30714 arg1 = reinterpret_cast< wxWindow * >(argp1);
30715 {
30716 PyThreadState* __tstate = wxPyBeginAllowThreads();
30717 result = ((wxWindow const *)arg1)->GetPosition();
30718 wxPyEndAllowThreads(__tstate);
30719 if (PyErr_Occurred()) SWIG_fail;
30720 }
30721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30722 return resultobj;
30723 fail:
30724 return NULL;
30725 }
30726
30727
30728 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30729 PyObject *resultobj = 0;
30730 wxWindow *arg1 = (wxWindow *) 0 ;
30731 int *arg2 = (int *) 0 ;
30732 int *arg3 = (int *) 0 ;
30733 void *argp1 = 0 ;
30734 int res1 = 0 ;
30735 int temp2 ;
30736 int res2 = SWIG_TMPOBJ ;
30737 int temp3 ;
30738 int res3 = SWIG_TMPOBJ ;
30739 PyObject *swig_obj[1] ;
30740
30741 arg2 = &temp2;
30742 arg3 = &temp3;
30743 if (!args) SWIG_fail;
30744 swig_obj[0] = args;
30745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30748 }
30749 arg1 = reinterpret_cast< wxWindow * >(argp1);
30750 {
30751 PyThreadState* __tstate = wxPyBeginAllowThreads();
30752 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30753 wxPyEndAllowThreads(__tstate);
30754 if (PyErr_Occurred()) SWIG_fail;
30755 }
30756 resultobj = SWIG_Py_Void();
30757 if (SWIG_IsTmpObj(res2)) {
30758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30759 } else {
30760 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30762 }
30763 if (SWIG_IsTmpObj(res3)) {
30764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30765 } else {
30766 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30768 }
30769 return resultobj;
30770 fail:
30771 return NULL;
30772 }
30773
30774
30775 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30776 PyObject *resultobj = 0;
30777 wxWindow *arg1 = (wxWindow *) 0 ;
30778 wxPoint result;
30779 void *argp1 = 0 ;
30780 int res1 = 0 ;
30781 PyObject *swig_obj[1] ;
30782
30783 if (!args) SWIG_fail;
30784 swig_obj[0] = args;
30785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30786 if (!SWIG_IsOK(res1)) {
30787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30788 }
30789 arg1 = reinterpret_cast< wxWindow * >(argp1);
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 result = ((wxWindow const *)arg1)->GetScreenPosition();
30793 wxPyEndAllowThreads(__tstate);
30794 if (PyErr_Occurred()) SWIG_fail;
30795 }
30796 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30797 return resultobj;
30798 fail:
30799 return NULL;
30800 }
30801
30802
30803 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30804 PyObject *resultobj = 0;
30805 wxWindow *arg1 = (wxWindow *) 0 ;
30806 int *arg2 = (int *) 0 ;
30807 int *arg3 = (int *) 0 ;
30808 void *argp1 = 0 ;
30809 int res1 = 0 ;
30810 int temp2 ;
30811 int res2 = SWIG_TMPOBJ ;
30812 int temp3 ;
30813 int res3 = SWIG_TMPOBJ ;
30814 PyObject *swig_obj[1] ;
30815
30816 arg2 = &temp2;
30817 arg3 = &temp3;
30818 if (!args) SWIG_fail;
30819 swig_obj[0] = args;
30820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30821 if (!SWIG_IsOK(res1)) {
30822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30823 }
30824 arg1 = reinterpret_cast< wxWindow * >(argp1);
30825 {
30826 PyThreadState* __tstate = wxPyBeginAllowThreads();
30827 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30828 wxPyEndAllowThreads(__tstate);
30829 if (PyErr_Occurred()) SWIG_fail;
30830 }
30831 resultobj = SWIG_Py_Void();
30832 if (SWIG_IsTmpObj(res2)) {
30833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30834 } else {
30835 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30837 }
30838 if (SWIG_IsTmpObj(res3)) {
30839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30840 } else {
30841 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30843 }
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30851 PyObject *resultobj = 0;
30852 wxWindow *arg1 = (wxWindow *) 0 ;
30853 wxRect result;
30854 void *argp1 = 0 ;
30855 int res1 = 0 ;
30856 PyObject *swig_obj[1] ;
30857
30858 if (!args) SWIG_fail;
30859 swig_obj[0] = args;
30860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30861 if (!SWIG_IsOK(res1)) {
30862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30863 }
30864 arg1 = reinterpret_cast< wxWindow * >(argp1);
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 result = ((wxWindow const *)arg1)->GetScreenRect();
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30872 return resultobj;
30873 fail:
30874 return NULL;
30875 }
30876
30877
30878 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30879 PyObject *resultobj = 0;
30880 wxWindow *arg1 = (wxWindow *) 0 ;
30881 wxSize result;
30882 void *argp1 = 0 ;
30883 int res1 = 0 ;
30884 PyObject *swig_obj[1] ;
30885
30886 if (!args) SWIG_fail;
30887 swig_obj[0] = args;
30888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30889 if (!SWIG_IsOK(res1)) {
30890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30891 }
30892 arg1 = reinterpret_cast< wxWindow * >(argp1);
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 result = ((wxWindow const *)arg1)->GetSize();
30896 wxPyEndAllowThreads(__tstate);
30897 if (PyErr_Occurred()) SWIG_fail;
30898 }
30899 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30907 PyObject *resultobj = 0;
30908 wxWindow *arg1 = (wxWindow *) 0 ;
30909 int *arg2 = (int *) 0 ;
30910 int *arg3 = (int *) 0 ;
30911 void *argp1 = 0 ;
30912 int res1 = 0 ;
30913 int temp2 ;
30914 int res2 = SWIG_TMPOBJ ;
30915 int temp3 ;
30916 int res3 = SWIG_TMPOBJ ;
30917 PyObject *swig_obj[1] ;
30918
30919 arg2 = &temp2;
30920 arg3 = &temp3;
30921 if (!args) SWIG_fail;
30922 swig_obj[0] = args;
30923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30924 if (!SWIG_IsOK(res1)) {
30925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30926 }
30927 arg1 = reinterpret_cast< wxWindow * >(argp1);
30928 {
30929 PyThreadState* __tstate = wxPyBeginAllowThreads();
30930 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30931 wxPyEndAllowThreads(__tstate);
30932 if (PyErr_Occurred()) SWIG_fail;
30933 }
30934 resultobj = SWIG_Py_Void();
30935 if (SWIG_IsTmpObj(res2)) {
30936 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30937 } else {
30938 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30940 }
30941 if (SWIG_IsTmpObj(res3)) {
30942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30943 } else {
30944 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30946 }
30947 return resultobj;
30948 fail:
30949 return NULL;
30950 }
30951
30952
30953 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30954 PyObject *resultobj = 0;
30955 wxWindow *arg1 = (wxWindow *) 0 ;
30956 wxRect result;
30957 void *argp1 = 0 ;
30958 int res1 = 0 ;
30959 PyObject *swig_obj[1] ;
30960
30961 if (!args) SWIG_fail;
30962 swig_obj[0] = args;
30963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30964 if (!SWIG_IsOK(res1)) {
30965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30966 }
30967 arg1 = reinterpret_cast< wxWindow * >(argp1);
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 result = ((wxWindow const *)arg1)->GetRect();
30971 wxPyEndAllowThreads(__tstate);
30972 if (PyErr_Occurred()) SWIG_fail;
30973 }
30974 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30975 return resultobj;
30976 fail:
30977 return NULL;
30978 }
30979
30980
30981 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30982 PyObject *resultobj = 0;
30983 wxWindow *arg1 = (wxWindow *) 0 ;
30984 wxSize result;
30985 void *argp1 = 0 ;
30986 int res1 = 0 ;
30987 PyObject *swig_obj[1] ;
30988
30989 if (!args) SWIG_fail;
30990 swig_obj[0] = args;
30991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30992 if (!SWIG_IsOK(res1)) {
30993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30994 }
30995 arg1 = reinterpret_cast< wxWindow * >(argp1);
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 result = ((wxWindow const *)arg1)->GetClientSize();
30999 wxPyEndAllowThreads(__tstate);
31000 if (PyErr_Occurred()) SWIG_fail;
31001 }
31002 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31003 return resultobj;
31004 fail:
31005 return NULL;
31006 }
31007
31008
31009 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31010 PyObject *resultobj = 0;
31011 wxWindow *arg1 = (wxWindow *) 0 ;
31012 int *arg2 = (int *) 0 ;
31013 int *arg3 = (int *) 0 ;
31014 void *argp1 = 0 ;
31015 int res1 = 0 ;
31016 int temp2 ;
31017 int res2 = SWIG_TMPOBJ ;
31018 int temp3 ;
31019 int res3 = SWIG_TMPOBJ ;
31020 PyObject *swig_obj[1] ;
31021
31022 arg2 = &temp2;
31023 arg3 = &temp3;
31024 if (!args) SWIG_fail;
31025 swig_obj[0] = args;
31026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31027 if (!SWIG_IsOK(res1)) {
31028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31029 }
31030 arg1 = reinterpret_cast< wxWindow * >(argp1);
31031 {
31032 PyThreadState* __tstate = wxPyBeginAllowThreads();
31033 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31034 wxPyEndAllowThreads(__tstate);
31035 if (PyErr_Occurred()) SWIG_fail;
31036 }
31037 resultobj = SWIG_Py_Void();
31038 if (SWIG_IsTmpObj(res2)) {
31039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31040 } else {
31041 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31043 }
31044 if (SWIG_IsTmpObj(res3)) {
31045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31046 } else {
31047 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31049 }
31050 return resultobj;
31051 fail:
31052 return NULL;
31053 }
31054
31055
31056 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31057 PyObject *resultobj = 0;
31058 wxWindow *arg1 = (wxWindow *) 0 ;
31059 wxPoint result;
31060 void *argp1 = 0 ;
31061 int res1 = 0 ;
31062 PyObject *swig_obj[1] ;
31063
31064 if (!args) SWIG_fail;
31065 swig_obj[0] = args;
31066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31067 if (!SWIG_IsOK(res1)) {
31068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31069 }
31070 arg1 = reinterpret_cast< wxWindow * >(argp1);
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31085 PyObject *resultobj = 0;
31086 wxWindow *arg1 = (wxWindow *) 0 ;
31087 wxRect result;
31088 void *argp1 = 0 ;
31089 int res1 = 0 ;
31090 PyObject *swig_obj[1] ;
31091
31092 if (!args) SWIG_fail;
31093 swig_obj[0] = args;
31094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31095 if (!SWIG_IsOK(res1)) {
31096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31097 }
31098 arg1 = reinterpret_cast< wxWindow * >(argp1);
31099 {
31100 PyThreadState* __tstate = wxPyBeginAllowThreads();
31101 result = ((wxWindow const *)arg1)->GetClientRect();
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31106 return resultobj;
31107 fail:
31108 return NULL;
31109 }
31110
31111
31112 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31113 PyObject *resultobj = 0;
31114 wxWindow *arg1 = (wxWindow *) 0 ;
31115 wxSize result;
31116 void *argp1 = 0 ;
31117 int res1 = 0 ;
31118 PyObject *swig_obj[1] ;
31119
31120 if (!args) SWIG_fail;
31121 swig_obj[0] = args;
31122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31123 if (!SWIG_IsOK(res1)) {
31124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31125 }
31126 arg1 = reinterpret_cast< wxWindow * >(argp1);
31127 {
31128 PyThreadState* __tstate = wxPyBeginAllowThreads();
31129 result = ((wxWindow const *)arg1)->GetBestSize();
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31141 PyObject *resultobj = 0;
31142 wxWindow *arg1 = (wxWindow *) 0 ;
31143 int *arg2 = (int *) 0 ;
31144 int *arg3 = (int *) 0 ;
31145 void *argp1 = 0 ;
31146 int res1 = 0 ;
31147 int temp2 ;
31148 int res2 = SWIG_TMPOBJ ;
31149 int temp3 ;
31150 int res3 = SWIG_TMPOBJ ;
31151 PyObject *swig_obj[1] ;
31152
31153 arg2 = &temp2;
31154 arg3 = &temp3;
31155 if (!args) SWIG_fail;
31156 swig_obj[0] = args;
31157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31158 if (!SWIG_IsOK(res1)) {
31159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31160 }
31161 arg1 = reinterpret_cast< wxWindow * >(argp1);
31162 {
31163 PyThreadState* __tstate = wxPyBeginAllowThreads();
31164 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31165 wxPyEndAllowThreads(__tstate);
31166 if (PyErr_Occurred()) SWIG_fail;
31167 }
31168 resultobj = SWIG_Py_Void();
31169 if (SWIG_IsTmpObj(res2)) {
31170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31171 } else {
31172 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31174 }
31175 if (SWIG_IsTmpObj(res3)) {
31176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31177 } else {
31178 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31180 }
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(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_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31199 }
31200 arg1 = reinterpret_cast< wxWindow * >(argp1);
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 (arg1)->InvalidateBestSize();
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_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31215 PyObject *resultobj = 0;
31216 wxWindow *arg1 = (wxWindow *) 0 ;
31217 wxSize *arg2 = 0 ;
31218 void *argp1 = 0 ;
31219 int res1 = 0 ;
31220 wxSize temp2 ;
31221 PyObject * obj0 = 0 ;
31222 PyObject * obj1 = 0 ;
31223 char * kwnames[] = {
31224 (char *) "self",(char *) "size", NULL
31225 };
31226
31227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31229 if (!SWIG_IsOK(res1)) {
31230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31231 }
31232 arg1 = reinterpret_cast< wxWindow * >(argp1);
31233 {
31234 arg2 = &temp2;
31235 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31236 }
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 resultobj = SWIG_Py_Void();
31244 return resultobj;
31245 fail:
31246 return NULL;
31247 }
31248
31249
31250 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31251 PyObject *resultobj = 0;
31252 wxWindow *arg1 = (wxWindow *) 0 ;
31253 wxSize result;
31254 void *argp1 = 0 ;
31255 int res1 = 0 ;
31256 PyObject *swig_obj[1] ;
31257
31258 if (!args) SWIG_fail;
31259 swig_obj[0] = args;
31260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31261 if (!SWIG_IsOK(res1)) {
31262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31263 }
31264 arg1 = reinterpret_cast< wxWindow * >(argp1);
31265 {
31266 PyThreadState* __tstate = wxPyBeginAllowThreads();
31267 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31268 wxPyEndAllowThreads(__tstate);
31269 if (PyErr_Occurred()) SWIG_fail;
31270 }
31271 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31272 return resultobj;
31273 fail:
31274 return NULL;
31275 }
31276
31277
31278 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31279 PyObject *resultobj = 0;
31280 wxWindow *arg1 = (wxWindow *) 0 ;
31281 wxSize result;
31282 void *argp1 = 0 ;
31283 int res1 = 0 ;
31284 PyObject *swig_obj[1] ;
31285
31286 if (!args) SWIG_fail;
31287 swig_obj[0] = args;
31288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31289 if (!SWIG_IsOK(res1)) {
31290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31291 }
31292 arg1 = reinterpret_cast< wxWindow * >(argp1);
31293 {
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31300 return resultobj;
31301 fail:
31302 return NULL;
31303 }
31304
31305
31306 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31307 PyObject *resultobj = 0;
31308 wxWindow *arg1 = (wxWindow *) 0 ;
31309 int arg2 = (int) wxBOTH ;
31310 void *argp1 = 0 ;
31311 int res1 = 0 ;
31312 int val2 ;
31313 int ecode2 = 0 ;
31314 PyObject * obj0 = 0 ;
31315 PyObject * obj1 = 0 ;
31316 char * kwnames[] = {
31317 (char *) "self",(char *) "direction", NULL
31318 };
31319
31320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31322 if (!SWIG_IsOK(res1)) {
31323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31324 }
31325 arg1 = reinterpret_cast< wxWindow * >(argp1);
31326 if (obj1) {
31327 ecode2 = SWIG_AsVal_int(obj1, &val2);
31328 if (!SWIG_IsOK(ecode2)) {
31329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31330 }
31331 arg2 = static_cast< int >(val2);
31332 }
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 (arg1)->Center(arg2);
31336 wxPyEndAllowThreads(__tstate);
31337 if (PyErr_Occurred()) SWIG_fail;
31338 }
31339 resultobj = SWIG_Py_Void();
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj = 0;
31348 wxWindow *arg1 = (wxWindow *) 0 ;
31349 int arg2 = (int) wxBOTH ;
31350 void *argp1 = 0 ;
31351 int res1 = 0 ;
31352 int val2 ;
31353 int ecode2 = 0 ;
31354 PyObject * obj0 = 0 ;
31355 PyObject * obj1 = 0 ;
31356 char * kwnames[] = {
31357 (char *) "self",(char *) "dir", NULL
31358 };
31359
31360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31362 if (!SWIG_IsOK(res1)) {
31363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31364 }
31365 arg1 = reinterpret_cast< wxWindow * >(argp1);
31366 if (obj1) {
31367 ecode2 = SWIG_AsVal_int(obj1, &val2);
31368 if (!SWIG_IsOK(ecode2)) {
31369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31370 }
31371 arg2 = static_cast< int >(val2);
31372 }
31373 {
31374 PyThreadState* __tstate = wxPyBeginAllowThreads();
31375 (arg1)->CenterOnParent(arg2);
31376 wxPyEndAllowThreads(__tstate);
31377 if (PyErr_Occurred()) SWIG_fail;
31378 }
31379 resultobj = SWIG_Py_Void();
31380 return resultobj;
31381 fail:
31382 return NULL;
31383 }
31384
31385
31386 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31387 PyObject *resultobj = 0;
31388 wxWindow *arg1 = (wxWindow *) 0 ;
31389 void *argp1 = 0 ;
31390 int res1 = 0 ;
31391 PyObject *swig_obj[1] ;
31392
31393 if (!args) SWIG_fail;
31394 swig_obj[0] = args;
31395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31396 if (!SWIG_IsOK(res1)) {
31397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31398 }
31399 arg1 = reinterpret_cast< wxWindow * >(argp1);
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 (arg1)->Fit();
31403 wxPyEndAllowThreads(__tstate);
31404 if (PyErr_Occurred()) SWIG_fail;
31405 }
31406 resultobj = SWIG_Py_Void();
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31414 PyObject *resultobj = 0;
31415 wxWindow *arg1 = (wxWindow *) 0 ;
31416 void *argp1 = 0 ;
31417 int res1 = 0 ;
31418 PyObject *swig_obj[1] ;
31419
31420 if (!args) SWIG_fail;
31421 swig_obj[0] = args;
31422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31423 if (!SWIG_IsOK(res1)) {
31424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31425 }
31426 arg1 = reinterpret_cast< wxWindow * >(argp1);
31427 {
31428 PyThreadState* __tstate = wxPyBeginAllowThreads();
31429 (arg1)->FitInside();
31430 wxPyEndAllowThreads(__tstate);
31431 if (PyErr_Occurred()) SWIG_fail;
31432 }
31433 resultobj = SWIG_Py_Void();
31434 return resultobj;
31435 fail:
31436 return NULL;
31437 }
31438
31439
31440 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31441 PyObject *resultobj = 0;
31442 wxWindow *arg1 = (wxWindow *) 0 ;
31443 int arg2 ;
31444 int arg3 ;
31445 int arg4 = (int) -1 ;
31446 int arg5 = (int) -1 ;
31447 int arg6 = (int) -1 ;
31448 int arg7 = (int) -1 ;
31449 void *argp1 = 0 ;
31450 int res1 = 0 ;
31451 int val2 ;
31452 int ecode2 = 0 ;
31453 int val3 ;
31454 int ecode3 = 0 ;
31455 int val4 ;
31456 int ecode4 = 0 ;
31457 int val5 ;
31458 int ecode5 = 0 ;
31459 int val6 ;
31460 int ecode6 = 0 ;
31461 int val7 ;
31462 int ecode7 = 0 ;
31463 PyObject * obj0 = 0 ;
31464 PyObject * obj1 = 0 ;
31465 PyObject * obj2 = 0 ;
31466 PyObject * obj3 = 0 ;
31467 PyObject * obj4 = 0 ;
31468 PyObject * obj5 = 0 ;
31469 PyObject * obj6 = 0 ;
31470 char * kwnames[] = {
31471 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31472 };
31473
31474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31476 if (!SWIG_IsOK(res1)) {
31477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31478 }
31479 arg1 = reinterpret_cast< wxWindow * >(argp1);
31480 ecode2 = SWIG_AsVal_int(obj1, &val2);
31481 if (!SWIG_IsOK(ecode2)) {
31482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31483 }
31484 arg2 = static_cast< int >(val2);
31485 ecode3 = SWIG_AsVal_int(obj2, &val3);
31486 if (!SWIG_IsOK(ecode3)) {
31487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31488 }
31489 arg3 = static_cast< int >(val3);
31490 if (obj3) {
31491 ecode4 = SWIG_AsVal_int(obj3, &val4);
31492 if (!SWIG_IsOK(ecode4)) {
31493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31494 }
31495 arg4 = static_cast< int >(val4);
31496 }
31497 if (obj4) {
31498 ecode5 = SWIG_AsVal_int(obj4, &val5);
31499 if (!SWIG_IsOK(ecode5)) {
31500 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31501 }
31502 arg5 = static_cast< int >(val5);
31503 }
31504 if (obj5) {
31505 ecode6 = SWIG_AsVal_int(obj5, &val6);
31506 if (!SWIG_IsOK(ecode6)) {
31507 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31508 }
31509 arg6 = static_cast< int >(val6);
31510 }
31511 if (obj6) {
31512 ecode7 = SWIG_AsVal_int(obj6, &val7);
31513 if (!SWIG_IsOK(ecode7)) {
31514 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31515 }
31516 arg7 = static_cast< int >(val7);
31517 }
31518 {
31519 PyThreadState* __tstate = wxPyBeginAllowThreads();
31520 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31521 wxPyEndAllowThreads(__tstate);
31522 if (PyErr_Occurred()) SWIG_fail;
31523 }
31524 resultobj = SWIG_Py_Void();
31525 return resultobj;
31526 fail:
31527 return NULL;
31528 }
31529
31530
31531 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31532 PyObject *resultobj = 0;
31533 wxWindow *arg1 = (wxWindow *) 0 ;
31534 wxSize *arg2 = 0 ;
31535 wxSize const &arg3_defvalue = wxDefaultSize ;
31536 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31537 wxSize const &arg4_defvalue = wxDefaultSize ;
31538 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31539 void *argp1 = 0 ;
31540 int res1 = 0 ;
31541 wxSize temp2 ;
31542 wxSize temp3 ;
31543 wxSize temp4 ;
31544 PyObject * obj0 = 0 ;
31545 PyObject * obj1 = 0 ;
31546 PyObject * obj2 = 0 ;
31547 PyObject * obj3 = 0 ;
31548 char * kwnames[] = {
31549 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31550 };
31551
31552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31554 if (!SWIG_IsOK(res1)) {
31555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31556 }
31557 arg1 = reinterpret_cast< wxWindow * >(argp1);
31558 {
31559 arg2 = &temp2;
31560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31561 }
31562 if (obj2) {
31563 {
31564 arg3 = &temp3;
31565 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31566 }
31567 }
31568 if (obj3) {
31569 {
31570 arg4 = &temp4;
31571 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31572 }
31573 }
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_Py_Void();
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31588 PyObject *resultobj = 0;
31589 wxWindow *arg1 = (wxWindow *) 0 ;
31590 int arg2 ;
31591 int arg3 ;
31592 int arg4 = (int) -1 ;
31593 int arg5 = (int) -1 ;
31594 void *argp1 = 0 ;
31595 int res1 = 0 ;
31596 int val2 ;
31597 int ecode2 = 0 ;
31598 int val3 ;
31599 int ecode3 = 0 ;
31600 int val4 ;
31601 int ecode4 = 0 ;
31602 int val5 ;
31603 int ecode5 = 0 ;
31604 PyObject * obj0 = 0 ;
31605 PyObject * obj1 = 0 ;
31606 PyObject * obj2 = 0 ;
31607 PyObject * obj3 = 0 ;
31608 PyObject * obj4 = 0 ;
31609 char * kwnames[] = {
31610 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31611 };
31612
31613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31615 if (!SWIG_IsOK(res1)) {
31616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31617 }
31618 arg1 = reinterpret_cast< wxWindow * >(argp1);
31619 ecode2 = SWIG_AsVal_int(obj1, &val2);
31620 if (!SWIG_IsOK(ecode2)) {
31621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31622 }
31623 arg2 = static_cast< int >(val2);
31624 ecode3 = SWIG_AsVal_int(obj2, &val3);
31625 if (!SWIG_IsOK(ecode3)) {
31626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31627 }
31628 arg3 = static_cast< int >(val3);
31629 if (obj3) {
31630 ecode4 = SWIG_AsVal_int(obj3, &val4);
31631 if (!SWIG_IsOK(ecode4)) {
31632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31633 }
31634 arg4 = static_cast< int >(val4);
31635 }
31636 if (obj4) {
31637 ecode5 = SWIG_AsVal_int(obj4, &val5);
31638 if (!SWIG_IsOK(ecode5)) {
31639 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31640 }
31641 arg5 = static_cast< int >(val5);
31642 }
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31646 wxPyEndAllowThreads(__tstate);
31647 if (PyErr_Occurred()) SWIG_fail;
31648 }
31649 resultobj = SWIG_Py_Void();
31650 return resultobj;
31651 fail:
31652 return NULL;
31653 }
31654
31655
31656 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31657 PyObject *resultobj = 0;
31658 wxWindow *arg1 = (wxWindow *) 0 ;
31659 wxSize *arg2 = 0 ;
31660 wxSize const &arg3_defvalue = wxDefaultSize ;
31661 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31662 void *argp1 = 0 ;
31663 int res1 = 0 ;
31664 wxSize temp2 ;
31665 wxSize temp3 ;
31666 PyObject * obj0 = 0 ;
31667 PyObject * obj1 = 0 ;
31668 PyObject * obj2 = 0 ;
31669 char * kwnames[] = {
31670 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31671 };
31672
31673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31675 if (!SWIG_IsOK(res1)) {
31676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31677 }
31678 arg1 = reinterpret_cast< wxWindow * >(argp1);
31679 {
31680 arg2 = &temp2;
31681 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31682 }
31683 if (obj2) {
31684 {
31685 arg3 = &temp3;
31686 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31687 }
31688 }
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31692 wxPyEndAllowThreads(__tstate);
31693 if (PyErr_Occurred()) SWIG_fail;
31694 }
31695 resultobj = SWIG_Py_Void();
31696 return resultobj;
31697 fail:
31698 return NULL;
31699 }
31700
31701
31702 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31703 PyObject *resultobj = 0;
31704 wxWindow *arg1 = (wxWindow *) 0 ;
31705 wxSize result;
31706 void *argp1 = 0 ;
31707 int res1 = 0 ;
31708 PyObject *swig_obj[1] ;
31709
31710 if (!args) SWIG_fail;
31711 swig_obj[0] = args;
31712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31713 if (!SWIG_IsOK(res1)) {
31714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31715 }
31716 arg1 = reinterpret_cast< wxWindow * >(argp1);
31717 {
31718 PyThreadState* __tstate = wxPyBeginAllowThreads();
31719 result = ((wxWindow const *)arg1)->GetMaxSize();
31720 wxPyEndAllowThreads(__tstate);
31721 if (PyErr_Occurred()) SWIG_fail;
31722 }
31723 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31724 return resultobj;
31725 fail:
31726 return NULL;
31727 }
31728
31729
31730 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31731 PyObject *resultobj = 0;
31732 wxWindow *arg1 = (wxWindow *) 0 ;
31733 wxSize result;
31734 void *argp1 = 0 ;
31735 int res1 = 0 ;
31736 PyObject *swig_obj[1] ;
31737
31738 if (!args) SWIG_fail;
31739 swig_obj[0] = args;
31740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31741 if (!SWIG_IsOK(res1)) {
31742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31743 }
31744 arg1 = reinterpret_cast< wxWindow * >(argp1);
31745 {
31746 PyThreadState* __tstate = wxPyBeginAllowThreads();
31747 result = ((wxWindow const *)arg1)->GetMinSize();
31748 wxPyEndAllowThreads(__tstate);
31749 if (PyErr_Occurred()) SWIG_fail;
31750 }
31751 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31752 return resultobj;
31753 fail:
31754 return NULL;
31755 }
31756
31757
31758 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31759 PyObject *resultobj = 0;
31760 wxWindow *arg1 = (wxWindow *) 0 ;
31761 wxSize *arg2 = 0 ;
31762 void *argp1 = 0 ;
31763 int res1 = 0 ;
31764 wxSize temp2 ;
31765 PyObject * obj0 = 0 ;
31766 PyObject * obj1 = 0 ;
31767 char * kwnames[] = {
31768 (char *) "self",(char *) "minSize", NULL
31769 };
31770
31771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31773 if (!SWIG_IsOK(res1)) {
31774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31775 }
31776 arg1 = reinterpret_cast< wxWindow * >(argp1);
31777 {
31778 arg2 = &temp2;
31779 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31780 }
31781 {
31782 PyThreadState* __tstate = wxPyBeginAllowThreads();
31783 (arg1)->SetMinSize((wxSize const &)*arg2);
31784 wxPyEndAllowThreads(__tstate);
31785 if (PyErr_Occurred()) SWIG_fail;
31786 }
31787 resultobj = SWIG_Py_Void();
31788 return resultobj;
31789 fail:
31790 return NULL;
31791 }
31792
31793
31794 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31795 PyObject *resultobj = 0;
31796 wxWindow *arg1 = (wxWindow *) 0 ;
31797 wxSize *arg2 = 0 ;
31798 void *argp1 = 0 ;
31799 int res1 = 0 ;
31800 wxSize temp2 ;
31801 PyObject * obj0 = 0 ;
31802 PyObject * obj1 = 0 ;
31803 char * kwnames[] = {
31804 (char *) "self",(char *) "maxSize", NULL
31805 };
31806
31807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31809 if (!SWIG_IsOK(res1)) {
31810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31811 }
31812 arg1 = reinterpret_cast< wxWindow * >(argp1);
31813 {
31814 arg2 = &temp2;
31815 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31816 }
31817 {
31818 PyThreadState* __tstate = wxPyBeginAllowThreads();
31819 (arg1)->SetMaxSize((wxSize const &)*arg2);
31820 wxPyEndAllowThreads(__tstate);
31821 if (PyErr_Occurred()) SWIG_fail;
31822 }
31823 resultobj = SWIG_Py_Void();
31824 return resultobj;
31825 fail:
31826 return NULL;
31827 }
31828
31829
31830 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31831 PyObject *resultobj = 0;
31832 wxWindow *arg1 = (wxWindow *) 0 ;
31833 int result;
31834 void *argp1 = 0 ;
31835 int res1 = 0 ;
31836 PyObject *swig_obj[1] ;
31837
31838 if (!args) SWIG_fail;
31839 swig_obj[0] = args;
31840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31841 if (!SWIG_IsOK(res1)) {
31842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31843 }
31844 arg1 = reinterpret_cast< wxWindow * >(argp1);
31845 {
31846 PyThreadState* __tstate = wxPyBeginAllowThreads();
31847 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31848 wxPyEndAllowThreads(__tstate);
31849 if (PyErr_Occurred()) SWIG_fail;
31850 }
31851 resultobj = SWIG_From_int(static_cast< int >(result));
31852 return resultobj;
31853 fail:
31854 return NULL;
31855 }
31856
31857
31858 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31859 PyObject *resultobj = 0;
31860 wxWindow *arg1 = (wxWindow *) 0 ;
31861 int result;
31862 void *argp1 = 0 ;
31863 int res1 = 0 ;
31864 PyObject *swig_obj[1] ;
31865
31866 if (!args) SWIG_fail;
31867 swig_obj[0] = args;
31868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31869 if (!SWIG_IsOK(res1)) {
31870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31871 }
31872 arg1 = reinterpret_cast< wxWindow * >(argp1);
31873 {
31874 PyThreadState* __tstate = wxPyBeginAllowThreads();
31875 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31876 wxPyEndAllowThreads(__tstate);
31877 if (PyErr_Occurred()) SWIG_fail;
31878 }
31879 resultobj = SWIG_From_int(static_cast< int >(result));
31880 return resultobj;
31881 fail:
31882 return NULL;
31883 }
31884
31885
31886 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31887 PyObject *resultobj = 0;
31888 wxWindow *arg1 = (wxWindow *) 0 ;
31889 int result;
31890 void *argp1 = 0 ;
31891 int res1 = 0 ;
31892 PyObject *swig_obj[1] ;
31893
31894 if (!args) SWIG_fail;
31895 swig_obj[0] = args;
31896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31897 if (!SWIG_IsOK(res1)) {
31898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31899 }
31900 arg1 = reinterpret_cast< wxWindow * >(argp1);
31901 {
31902 PyThreadState* __tstate = wxPyBeginAllowThreads();
31903 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31904 wxPyEndAllowThreads(__tstate);
31905 if (PyErr_Occurred()) SWIG_fail;
31906 }
31907 resultobj = SWIG_From_int(static_cast< int >(result));
31908 return resultobj;
31909 fail:
31910 return NULL;
31911 }
31912
31913
31914 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31915 PyObject *resultobj = 0;
31916 wxWindow *arg1 = (wxWindow *) 0 ;
31917 int result;
31918 void *argp1 = 0 ;
31919 int res1 = 0 ;
31920 PyObject *swig_obj[1] ;
31921
31922 if (!args) SWIG_fail;
31923 swig_obj[0] = args;
31924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31925 if (!SWIG_IsOK(res1)) {
31926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31927 }
31928 arg1 = reinterpret_cast< wxWindow * >(argp1);
31929 {
31930 PyThreadState* __tstate = wxPyBeginAllowThreads();
31931 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31932 wxPyEndAllowThreads(__tstate);
31933 if (PyErr_Occurred()) SWIG_fail;
31934 }
31935 resultobj = SWIG_From_int(static_cast< int >(result));
31936 return resultobj;
31937 fail:
31938 return NULL;
31939 }
31940
31941
31942 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31943 PyObject *resultobj = 0;
31944 wxWindow *arg1 = (wxWindow *) 0 ;
31945 wxSize *arg2 = 0 ;
31946 void *argp1 = 0 ;
31947 int res1 = 0 ;
31948 wxSize temp2 ;
31949 PyObject * obj0 = 0 ;
31950 PyObject * obj1 = 0 ;
31951 char * kwnames[] = {
31952 (char *) "self",(char *) "size", NULL
31953 };
31954
31955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31957 if (!SWIG_IsOK(res1)) {
31958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31959 }
31960 arg1 = reinterpret_cast< wxWindow * >(argp1);
31961 {
31962 arg2 = &temp2;
31963 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31964 }
31965 {
31966 PyThreadState* __tstate = wxPyBeginAllowThreads();
31967 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31968 wxPyEndAllowThreads(__tstate);
31969 if (PyErr_Occurred()) SWIG_fail;
31970 }
31971 resultobj = SWIG_Py_Void();
31972 return resultobj;
31973 fail:
31974 return NULL;
31975 }
31976
31977
31978 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31979 PyObject *resultobj = 0;
31980 wxWindow *arg1 = (wxWindow *) 0 ;
31981 int arg2 ;
31982 int arg3 ;
31983 void *argp1 = 0 ;
31984 int res1 = 0 ;
31985 int val2 ;
31986 int ecode2 = 0 ;
31987 int val3 ;
31988 int ecode3 = 0 ;
31989 PyObject * obj0 = 0 ;
31990 PyObject * obj1 = 0 ;
31991 PyObject * obj2 = 0 ;
31992 char * kwnames[] = {
31993 (char *) "self",(char *) "w",(char *) "h", NULL
31994 };
31995
31996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31998 if (!SWIG_IsOK(res1)) {
31999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32000 }
32001 arg1 = reinterpret_cast< wxWindow * >(argp1);
32002 ecode2 = SWIG_AsVal_int(obj1, &val2);
32003 if (!SWIG_IsOK(ecode2)) {
32004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32005 }
32006 arg2 = static_cast< int >(val2);
32007 ecode3 = SWIG_AsVal_int(obj2, &val3);
32008 if (!SWIG_IsOK(ecode3)) {
32009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32010 }
32011 arg3 = static_cast< int >(val3);
32012 {
32013 PyThreadState* __tstate = wxPyBeginAllowThreads();
32014 (arg1)->SetVirtualSize(arg2,arg3);
32015 wxPyEndAllowThreads(__tstate);
32016 if (PyErr_Occurred()) SWIG_fail;
32017 }
32018 resultobj = SWIG_Py_Void();
32019 return resultobj;
32020 fail:
32021 return NULL;
32022 }
32023
32024
32025 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32026 PyObject *resultobj = 0;
32027 wxWindow *arg1 = (wxWindow *) 0 ;
32028 wxSize result;
32029 void *argp1 = 0 ;
32030 int res1 = 0 ;
32031 PyObject *swig_obj[1] ;
32032
32033 if (!args) SWIG_fail;
32034 swig_obj[0] = args;
32035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32036 if (!SWIG_IsOK(res1)) {
32037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32038 }
32039 arg1 = reinterpret_cast< wxWindow * >(argp1);
32040 {
32041 PyThreadState* __tstate = wxPyBeginAllowThreads();
32042 result = ((wxWindow const *)arg1)->GetVirtualSize();
32043 wxPyEndAllowThreads(__tstate);
32044 if (PyErr_Occurred()) SWIG_fail;
32045 }
32046 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32047 return resultobj;
32048 fail:
32049 return NULL;
32050 }
32051
32052
32053 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32054 PyObject *resultobj = 0;
32055 wxWindow *arg1 = (wxWindow *) 0 ;
32056 int *arg2 = (int *) 0 ;
32057 int *arg3 = (int *) 0 ;
32058 void *argp1 = 0 ;
32059 int res1 = 0 ;
32060 int temp2 ;
32061 int res2 = SWIG_TMPOBJ ;
32062 int temp3 ;
32063 int res3 = SWIG_TMPOBJ ;
32064 PyObject *swig_obj[1] ;
32065
32066 arg2 = &temp2;
32067 arg3 = &temp3;
32068 if (!args) SWIG_fail;
32069 swig_obj[0] = args;
32070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32071 if (!SWIG_IsOK(res1)) {
32072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32073 }
32074 arg1 = reinterpret_cast< wxWindow * >(argp1);
32075 {
32076 PyThreadState* __tstate = wxPyBeginAllowThreads();
32077 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32078 wxPyEndAllowThreads(__tstate);
32079 if (PyErr_Occurred()) SWIG_fail;
32080 }
32081 resultobj = SWIG_Py_Void();
32082 if (SWIG_IsTmpObj(res2)) {
32083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32084 } else {
32085 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32087 }
32088 if (SWIG_IsTmpObj(res3)) {
32089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32090 } else {
32091 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32093 }
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32101 PyObject *resultobj = 0;
32102 wxWindow *arg1 = (wxWindow *) 0 ;
32103 wxSize result;
32104 void *argp1 = 0 ;
32105 int res1 = 0 ;
32106 PyObject *swig_obj[1] ;
32107
32108 if (!args) SWIG_fail;
32109 swig_obj[0] = args;
32110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32111 if (!SWIG_IsOK(res1)) {
32112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32113 }
32114 arg1 = reinterpret_cast< wxWindow * >(argp1);
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32122 return resultobj;
32123 fail:
32124 return NULL;
32125 }
32126
32127
32128 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32129 PyObject *resultobj = 0;
32130 wxWindow *arg1 = (wxWindow *) 0 ;
32131 bool arg2 = (bool) true ;
32132 bool result;
32133 void *argp1 = 0 ;
32134 int res1 = 0 ;
32135 bool val2 ;
32136 int ecode2 = 0 ;
32137 PyObject * obj0 = 0 ;
32138 PyObject * obj1 = 0 ;
32139 char * kwnames[] = {
32140 (char *) "self",(char *) "show", NULL
32141 };
32142
32143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32145 if (!SWIG_IsOK(res1)) {
32146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32147 }
32148 arg1 = reinterpret_cast< wxWindow * >(argp1);
32149 if (obj1) {
32150 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32151 if (!SWIG_IsOK(ecode2)) {
32152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32153 }
32154 arg2 = static_cast< bool >(val2);
32155 }
32156 {
32157 PyThreadState* __tstate = wxPyBeginAllowThreads();
32158 result = (bool)(arg1)->Show(arg2);
32159 wxPyEndAllowThreads(__tstate);
32160 if (PyErr_Occurred()) SWIG_fail;
32161 }
32162 {
32163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32164 }
32165 return resultobj;
32166 fail:
32167 return NULL;
32168 }
32169
32170
32171 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32172 PyObject *resultobj = 0;
32173 wxWindow *arg1 = (wxWindow *) 0 ;
32174 bool result;
32175 void *argp1 = 0 ;
32176 int res1 = 0 ;
32177 PyObject *swig_obj[1] ;
32178
32179 if (!args) SWIG_fail;
32180 swig_obj[0] = args;
32181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32182 if (!SWIG_IsOK(res1)) {
32183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32184 }
32185 arg1 = reinterpret_cast< wxWindow * >(argp1);
32186 {
32187 PyThreadState* __tstate = wxPyBeginAllowThreads();
32188 result = (bool)(arg1)->Hide();
32189 wxPyEndAllowThreads(__tstate);
32190 if (PyErr_Occurred()) SWIG_fail;
32191 }
32192 {
32193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32194 }
32195 return resultobj;
32196 fail:
32197 return NULL;
32198 }
32199
32200
32201 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32202 PyObject *resultobj = 0;
32203 wxWindow *arg1 = (wxWindow *) 0 ;
32204 bool arg2 = (bool) true ;
32205 bool result;
32206 void *argp1 = 0 ;
32207 int res1 = 0 ;
32208 bool val2 ;
32209 int ecode2 = 0 ;
32210 PyObject * obj0 = 0 ;
32211 PyObject * obj1 = 0 ;
32212 char * kwnames[] = {
32213 (char *) "self",(char *) "enable", NULL
32214 };
32215
32216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32220 }
32221 arg1 = reinterpret_cast< wxWindow * >(argp1);
32222 if (obj1) {
32223 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32224 if (!SWIG_IsOK(ecode2)) {
32225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32226 }
32227 arg2 = static_cast< bool >(val2);
32228 }
32229 {
32230 PyThreadState* __tstate = wxPyBeginAllowThreads();
32231 result = (bool)(arg1)->Enable(arg2);
32232 wxPyEndAllowThreads(__tstate);
32233 if (PyErr_Occurred()) SWIG_fail;
32234 }
32235 {
32236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32237 }
32238 return resultobj;
32239 fail:
32240 return NULL;
32241 }
32242
32243
32244 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32245 PyObject *resultobj = 0;
32246 wxWindow *arg1 = (wxWindow *) 0 ;
32247 bool result;
32248 void *argp1 = 0 ;
32249 int res1 = 0 ;
32250 PyObject *swig_obj[1] ;
32251
32252 if (!args) SWIG_fail;
32253 swig_obj[0] = args;
32254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32255 if (!SWIG_IsOK(res1)) {
32256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32257 }
32258 arg1 = reinterpret_cast< wxWindow * >(argp1);
32259 {
32260 PyThreadState* __tstate = wxPyBeginAllowThreads();
32261 result = (bool)(arg1)->Disable();
32262 wxPyEndAllowThreads(__tstate);
32263 if (PyErr_Occurred()) SWIG_fail;
32264 }
32265 {
32266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32267 }
32268 return resultobj;
32269 fail:
32270 return NULL;
32271 }
32272
32273
32274 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32275 PyObject *resultobj = 0;
32276 wxWindow *arg1 = (wxWindow *) 0 ;
32277 bool result;
32278 void *argp1 = 0 ;
32279 int res1 = 0 ;
32280 PyObject *swig_obj[1] ;
32281
32282 if (!args) SWIG_fail;
32283 swig_obj[0] = args;
32284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32285 if (!SWIG_IsOK(res1)) {
32286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32287 }
32288 arg1 = reinterpret_cast< wxWindow * >(argp1);
32289 {
32290 PyThreadState* __tstate = wxPyBeginAllowThreads();
32291 result = (bool)((wxWindow const *)arg1)->IsShown();
32292 wxPyEndAllowThreads(__tstate);
32293 if (PyErr_Occurred()) SWIG_fail;
32294 }
32295 {
32296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32297 }
32298 return resultobj;
32299 fail:
32300 return NULL;
32301 }
32302
32303
32304 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32305 PyObject *resultobj = 0;
32306 wxWindow *arg1 = (wxWindow *) 0 ;
32307 bool result;
32308 void *argp1 = 0 ;
32309 int res1 = 0 ;
32310 PyObject *swig_obj[1] ;
32311
32312 if (!args) SWIG_fail;
32313 swig_obj[0] = args;
32314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32315 if (!SWIG_IsOK(res1)) {
32316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32317 }
32318 arg1 = reinterpret_cast< wxWindow * >(argp1);
32319 {
32320 PyThreadState* __tstate = wxPyBeginAllowThreads();
32321 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32322 wxPyEndAllowThreads(__tstate);
32323 if (PyErr_Occurred()) SWIG_fail;
32324 }
32325 {
32326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32327 }
32328 return resultobj;
32329 fail:
32330 return NULL;
32331 }
32332
32333
32334 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32335 PyObject *resultobj = 0;
32336 wxWindow *arg1 = (wxWindow *) 0 ;
32337 long arg2 ;
32338 void *argp1 = 0 ;
32339 int res1 = 0 ;
32340 long val2 ;
32341 int ecode2 = 0 ;
32342 PyObject * obj0 = 0 ;
32343 PyObject * obj1 = 0 ;
32344 char * kwnames[] = {
32345 (char *) "self",(char *) "style", NULL
32346 };
32347
32348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32350 if (!SWIG_IsOK(res1)) {
32351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32352 }
32353 arg1 = reinterpret_cast< wxWindow * >(argp1);
32354 ecode2 = SWIG_AsVal_long(obj1, &val2);
32355 if (!SWIG_IsOK(ecode2)) {
32356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32357 }
32358 arg2 = static_cast< long >(val2);
32359 {
32360 PyThreadState* __tstate = wxPyBeginAllowThreads();
32361 (arg1)->SetWindowStyleFlag(arg2);
32362 wxPyEndAllowThreads(__tstate);
32363 if (PyErr_Occurred()) SWIG_fail;
32364 }
32365 resultobj = SWIG_Py_Void();
32366 return resultobj;
32367 fail:
32368 return NULL;
32369 }
32370
32371
32372 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32373 PyObject *resultobj = 0;
32374 wxWindow *arg1 = (wxWindow *) 0 ;
32375 long result;
32376 void *argp1 = 0 ;
32377 int res1 = 0 ;
32378 PyObject *swig_obj[1] ;
32379
32380 if (!args) SWIG_fail;
32381 swig_obj[0] = args;
32382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32383 if (!SWIG_IsOK(res1)) {
32384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32385 }
32386 arg1 = reinterpret_cast< wxWindow * >(argp1);
32387 {
32388 PyThreadState* __tstate = wxPyBeginAllowThreads();
32389 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32390 wxPyEndAllowThreads(__tstate);
32391 if (PyErr_Occurred()) SWIG_fail;
32392 }
32393 resultobj = SWIG_From_long(static_cast< long >(result));
32394 return resultobj;
32395 fail:
32396 return NULL;
32397 }
32398
32399
32400 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32401 PyObject *resultobj = 0;
32402 wxWindow *arg1 = (wxWindow *) 0 ;
32403 int arg2 ;
32404 bool result;
32405 void *argp1 = 0 ;
32406 int res1 = 0 ;
32407 int val2 ;
32408 int ecode2 = 0 ;
32409 PyObject * obj0 = 0 ;
32410 PyObject * obj1 = 0 ;
32411 char * kwnames[] = {
32412 (char *) "self",(char *) "flag", NULL
32413 };
32414
32415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32417 if (!SWIG_IsOK(res1)) {
32418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32419 }
32420 arg1 = reinterpret_cast< wxWindow * >(argp1);
32421 ecode2 = SWIG_AsVal_int(obj1, &val2);
32422 if (!SWIG_IsOK(ecode2)) {
32423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32424 }
32425 arg2 = static_cast< int >(val2);
32426 {
32427 PyThreadState* __tstate = wxPyBeginAllowThreads();
32428 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32429 wxPyEndAllowThreads(__tstate);
32430 if (PyErr_Occurred()) SWIG_fail;
32431 }
32432 {
32433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32434 }
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32442 PyObject *resultobj = 0;
32443 wxWindow *arg1 = (wxWindow *) 0 ;
32444 bool result;
32445 void *argp1 = 0 ;
32446 int res1 = 0 ;
32447 PyObject *swig_obj[1] ;
32448
32449 if (!args) SWIG_fail;
32450 swig_obj[0] = args;
32451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32452 if (!SWIG_IsOK(res1)) {
32453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32454 }
32455 arg1 = reinterpret_cast< wxWindow * >(argp1);
32456 {
32457 PyThreadState* __tstate = wxPyBeginAllowThreads();
32458 result = (bool)((wxWindow const *)arg1)->IsRetained();
32459 wxPyEndAllowThreads(__tstate);
32460 if (PyErr_Occurred()) SWIG_fail;
32461 }
32462 {
32463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32464 }
32465 return resultobj;
32466 fail:
32467 return NULL;
32468 }
32469
32470
32471 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32472 PyObject *resultobj = 0;
32473 wxWindow *arg1 = (wxWindow *) 0 ;
32474 long arg2 ;
32475 void *argp1 = 0 ;
32476 int res1 = 0 ;
32477 long val2 ;
32478 int ecode2 = 0 ;
32479 PyObject * obj0 = 0 ;
32480 PyObject * obj1 = 0 ;
32481 char * kwnames[] = {
32482 (char *) "self",(char *) "exStyle", NULL
32483 };
32484
32485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32487 if (!SWIG_IsOK(res1)) {
32488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32489 }
32490 arg1 = reinterpret_cast< wxWindow * >(argp1);
32491 ecode2 = SWIG_AsVal_long(obj1, &val2);
32492 if (!SWIG_IsOK(ecode2)) {
32493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32494 }
32495 arg2 = static_cast< long >(val2);
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 (arg1)->SetExtraStyle(arg2);
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 resultobj = SWIG_Py_Void();
32503 return resultobj;
32504 fail:
32505 return NULL;
32506 }
32507
32508
32509 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32510 PyObject *resultobj = 0;
32511 wxWindow *arg1 = (wxWindow *) 0 ;
32512 long result;
32513 void *argp1 = 0 ;
32514 int res1 = 0 ;
32515 PyObject *swig_obj[1] ;
32516
32517 if (!args) SWIG_fail;
32518 swig_obj[0] = args;
32519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32520 if (!SWIG_IsOK(res1)) {
32521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32522 }
32523 arg1 = reinterpret_cast< wxWindow * >(argp1);
32524 {
32525 PyThreadState* __tstate = wxPyBeginAllowThreads();
32526 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 resultobj = SWIG_From_long(static_cast< long >(result));
32531 return resultobj;
32532 fail:
32533 return NULL;
32534 }
32535
32536
32537 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32538 PyObject *resultobj = 0;
32539 wxWindow *arg1 = (wxWindow *) 0 ;
32540 bool arg2 = (bool) true ;
32541 void *argp1 = 0 ;
32542 int res1 = 0 ;
32543 bool val2 ;
32544 int ecode2 = 0 ;
32545 PyObject * obj0 = 0 ;
32546 PyObject * obj1 = 0 ;
32547 char * kwnames[] = {
32548 (char *) "self",(char *) "modal", NULL
32549 };
32550
32551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32553 if (!SWIG_IsOK(res1)) {
32554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32555 }
32556 arg1 = reinterpret_cast< wxWindow * >(argp1);
32557 if (obj1) {
32558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32559 if (!SWIG_IsOK(ecode2)) {
32560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32561 }
32562 arg2 = static_cast< bool >(val2);
32563 }
32564 {
32565 PyThreadState* __tstate = wxPyBeginAllowThreads();
32566 (arg1)->MakeModal(arg2);
32567 wxPyEndAllowThreads(__tstate);
32568 if (PyErr_Occurred()) SWIG_fail;
32569 }
32570 resultobj = SWIG_Py_Void();
32571 return resultobj;
32572 fail:
32573 return NULL;
32574 }
32575
32576
32577 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32578 PyObject *resultobj = 0;
32579 wxWindow *arg1 = (wxWindow *) 0 ;
32580 bool arg2 ;
32581 void *argp1 = 0 ;
32582 int res1 = 0 ;
32583 bool val2 ;
32584 int ecode2 = 0 ;
32585 PyObject * obj0 = 0 ;
32586 PyObject * obj1 = 0 ;
32587 char * kwnames[] = {
32588 (char *) "self",(char *) "enableTheme", NULL
32589 };
32590
32591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32593 if (!SWIG_IsOK(res1)) {
32594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32595 }
32596 arg1 = reinterpret_cast< wxWindow * >(argp1);
32597 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32598 if (!SWIG_IsOK(ecode2)) {
32599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32600 }
32601 arg2 = static_cast< bool >(val2);
32602 {
32603 PyThreadState* __tstate = wxPyBeginAllowThreads();
32604 (arg1)->SetThemeEnabled(arg2);
32605 wxPyEndAllowThreads(__tstate);
32606 if (PyErr_Occurred()) SWIG_fail;
32607 }
32608 resultobj = SWIG_Py_Void();
32609 return resultobj;
32610 fail:
32611 return NULL;
32612 }
32613
32614
32615 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32616 PyObject *resultobj = 0;
32617 wxWindow *arg1 = (wxWindow *) 0 ;
32618 bool result;
32619 void *argp1 = 0 ;
32620 int res1 = 0 ;
32621 PyObject *swig_obj[1] ;
32622
32623 if (!args) SWIG_fail;
32624 swig_obj[0] = args;
32625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32626 if (!SWIG_IsOK(res1)) {
32627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32628 }
32629 arg1 = reinterpret_cast< wxWindow * >(argp1);
32630 {
32631 PyThreadState* __tstate = wxPyBeginAllowThreads();
32632 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32633 wxPyEndAllowThreads(__tstate);
32634 if (PyErr_Occurred()) SWIG_fail;
32635 }
32636 {
32637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32638 }
32639 return resultobj;
32640 fail:
32641 return NULL;
32642 }
32643
32644
32645 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32646 PyObject *resultobj = 0;
32647 wxWindow *arg1 = (wxWindow *) 0 ;
32648 void *argp1 = 0 ;
32649 int res1 = 0 ;
32650 PyObject *swig_obj[1] ;
32651
32652 if (!args) SWIG_fail;
32653 swig_obj[0] = args;
32654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32655 if (!SWIG_IsOK(res1)) {
32656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32657 }
32658 arg1 = reinterpret_cast< wxWindow * >(argp1);
32659 {
32660 PyThreadState* __tstate = wxPyBeginAllowThreads();
32661 (arg1)->SetFocus();
32662 wxPyEndAllowThreads(__tstate);
32663 if (PyErr_Occurred()) SWIG_fail;
32664 }
32665 resultobj = SWIG_Py_Void();
32666 return resultobj;
32667 fail:
32668 return NULL;
32669 }
32670
32671
32672 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32673 PyObject *resultobj = 0;
32674 wxWindow *arg1 = (wxWindow *) 0 ;
32675 void *argp1 = 0 ;
32676 int res1 = 0 ;
32677 PyObject *swig_obj[1] ;
32678
32679 if (!args) SWIG_fail;
32680 swig_obj[0] = args;
32681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32682 if (!SWIG_IsOK(res1)) {
32683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32684 }
32685 arg1 = reinterpret_cast< wxWindow * >(argp1);
32686 {
32687 PyThreadState* __tstate = wxPyBeginAllowThreads();
32688 (arg1)->SetFocusFromKbd();
32689 wxPyEndAllowThreads(__tstate);
32690 if (PyErr_Occurred()) SWIG_fail;
32691 }
32692 resultobj = SWIG_Py_Void();
32693 return resultobj;
32694 fail:
32695 return NULL;
32696 }
32697
32698
32699 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32700 PyObject *resultobj = 0;
32701 wxWindow *result = 0 ;
32702
32703 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32704 {
32705 if (!wxPyCheckForApp()) SWIG_fail;
32706 PyThreadState* __tstate = wxPyBeginAllowThreads();
32707 result = (wxWindow *)wxWindow::FindFocus();
32708 wxPyEndAllowThreads(__tstate);
32709 if (PyErr_Occurred()) SWIG_fail;
32710 }
32711 {
32712 resultobj = wxPyMake_wxObject(result, 0);
32713 }
32714 return resultobj;
32715 fail:
32716 return NULL;
32717 }
32718
32719
32720 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32721 PyObject *resultobj = 0;
32722 wxWindow *arg1 = (wxWindow *) 0 ;
32723 bool result;
32724 void *argp1 = 0 ;
32725 int res1 = 0 ;
32726 PyObject *swig_obj[1] ;
32727
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_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32733 }
32734 arg1 = reinterpret_cast< wxWindow * >(argp1);
32735 {
32736 PyThreadState* __tstate = wxPyBeginAllowThreads();
32737 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32738 wxPyEndAllowThreads(__tstate);
32739 if (PyErr_Occurred()) SWIG_fail;
32740 }
32741 {
32742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32743 }
32744 return resultobj;
32745 fail:
32746 return NULL;
32747 }
32748
32749
32750 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32751 PyObject *resultobj = 0;
32752 wxWindow *arg1 = (wxWindow *) 0 ;
32753 bool result;
32754 void *argp1 = 0 ;
32755 int res1 = 0 ;
32756 PyObject *swig_obj[1] ;
32757
32758 if (!args) SWIG_fail;
32759 swig_obj[0] = args;
32760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32763 }
32764 arg1 = reinterpret_cast< wxWindow * >(argp1);
32765 {
32766 PyThreadState* __tstate = wxPyBeginAllowThreads();
32767 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32768 wxPyEndAllowThreads(__tstate);
32769 if (PyErr_Occurred()) SWIG_fail;
32770 }
32771 {
32772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32773 }
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32781 PyObject *resultobj = 0;
32782 wxWindow *arg1 = (wxWindow *) 0 ;
32783 wxWindow *result = 0 ;
32784 void *argp1 = 0 ;
32785 int res1 = 0 ;
32786 PyObject *swig_obj[1] ;
32787
32788 if (!args) SWIG_fail;
32789 swig_obj[0] = args;
32790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32791 if (!SWIG_IsOK(res1)) {
32792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32793 }
32794 arg1 = reinterpret_cast< wxWindow * >(argp1);
32795 {
32796 PyThreadState* __tstate = wxPyBeginAllowThreads();
32797 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32798 wxPyEndAllowThreads(__tstate);
32799 if (PyErr_Occurred()) SWIG_fail;
32800 }
32801 {
32802 resultobj = wxPyMake_wxObject(result, 0);
32803 }
32804 return resultobj;
32805 fail:
32806 return NULL;
32807 }
32808
32809
32810 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32811 PyObject *resultobj = 0;
32812 wxWindow *arg1 = (wxWindow *) 0 ;
32813 wxWindow *arg2 = (wxWindow *) 0 ;
32814 wxWindow *result = 0 ;
32815 void *argp1 = 0 ;
32816 int res1 = 0 ;
32817 void *argp2 = 0 ;
32818 int res2 = 0 ;
32819 PyObject * obj0 = 0 ;
32820 PyObject * obj1 = 0 ;
32821 char * kwnames[] = {
32822 (char *) "self",(char *) "child", NULL
32823 };
32824
32825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32827 if (!SWIG_IsOK(res1)) {
32828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32829 }
32830 arg1 = reinterpret_cast< wxWindow * >(argp1);
32831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32832 if (!SWIG_IsOK(res2)) {
32833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32834 }
32835 arg2 = reinterpret_cast< wxWindow * >(argp2);
32836 {
32837 PyThreadState* __tstate = wxPyBeginAllowThreads();
32838 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32839 wxPyEndAllowThreads(__tstate);
32840 if (PyErr_Occurred()) SWIG_fail;
32841 }
32842 {
32843 resultobj = wxPyMake_wxObject(result, 0);
32844 }
32845 return resultobj;
32846 fail:
32847 return NULL;
32848 }
32849
32850
32851 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32852 PyObject *resultobj = 0;
32853 wxWindow *arg1 = (wxWindow *) 0 ;
32854 wxWindow *arg2 = (wxWindow *) 0 ;
32855 void *argp1 = 0 ;
32856 int res1 = 0 ;
32857 void *argp2 = 0 ;
32858 int res2 = 0 ;
32859 PyObject * obj0 = 0 ;
32860 PyObject * obj1 = 0 ;
32861 char * kwnames[] = {
32862 (char *) "self",(char *) "win", NULL
32863 };
32864
32865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32867 if (!SWIG_IsOK(res1)) {
32868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32869 }
32870 arg1 = reinterpret_cast< wxWindow * >(argp1);
32871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32872 if (!SWIG_IsOK(res2)) {
32873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32874 }
32875 arg2 = reinterpret_cast< wxWindow * >(argp2);
32876 {
32877 PyThreadState* __tstate = wxPyBeginAllowThreads();
32878 (arg1)->SetTmpDefaultItem(arg2);
32879 wxPyEndAllowThreads(__tstate);
32880 if (PyErr_Occurred()) SWIG_fail;
32881 }
32882 resultobj = SWIG_Py_Void();
32883 return resultobj;
32884 fail:
32885 return NULL;
32886 }
32887
32888
32889 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32890 PyObject *resultobj = 0;
32891 wxWindow *arg1 = (wxWindow *) 0 ;
32892 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32893 bool result;
32894 void *argp1 = 0 ;
32895 int res1 = 0 ;
32896 int val2 ;
32897 int ecode2 = 0 ;
32898 PyObject * obj0 = 0 ;
32899 PyObject * obj1 = 0 ;
32900 char * kwnames[] = {
32901 (char *) "self",(char *) "flags", NULL
32902 };
32903
32904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32906 if (!SWIG_IsOK(res1)) {
32907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32908 }
32909 arg1 = reinterpret_cast< wxWindow * >(argp1);
32910 if (obj1) {
32911 ecode2 = SWIG_AsVal_int(obj1, &val2);
32912 if (!SWIG_IsOK(ecode2)) {
32913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32914 }
32915 arg2 = static_cast< int >(val2);
32916 }
32917 {
32918 PyThreadState* __tstate = wxPyBeginAllowThreads();
32919 result = (bool)(arg1)->Navigate(arg2);
32920 wxPyEndAllowThreads(__tstate);
32921 if (PyErr_Occurred()) SWIG_fail;
32922 }
32923 {
32924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32925 }
32926 return resultobj;
32927 fail:
32928 return NULL;
32929 }
32930
32931
32932 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32933 PyObject *resultobj = 0;
32934 wxWindow *arg1 = (wxWindow *) 0 ;
32935 wxWindow *arg2 = (wxWindow *) 0 ;
32936 void *argp1 = 0 ;
32937 int res1 = 0 ;
32938 void *argp2 = 0 ;
32939 int res2 = 0 ;
32940 PyObject * obj0 = 0 ;
32941 PyObject * obj1 = 0 ;
32942 char * kwnames[] = {
32943 (char *) "self",(char *) "win", NULL
32944 };
32945
32946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32948 if (!SWIG_IsOK(res1)) {
32949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32950 }
32951 arg1 = reinterpret_cast< wxWindow * >(argp1);
32952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32953 if (!SWIG_IsOK(res2)) {
32954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32955 }
32956 arg2 = reinterpret_cast< wxWindow * >(argp2);
32957 {
32958 PyThreadState* __tstate = wxPyBeginAllowThreads();
32959 (arg1)->MoveAfterInTabOrder(arg2);
32960 wxPyEndAllowThreads(__tstate);
32961 if (PyErr_Occurred()) SWIG_fail;
32962 }
32963 resultobj = SWIG_Py_Void();
32964 return resultobj;
32965 fail:
32966 return NULL;
32967 }
32968
32969
32970 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32971 PyObject *resultobj = 0;
32972 wxWindow *arg1 = (wxWindow *) 0 ;
32973 wxWindow *arg2 = (wxWindow *) 0 ;
32974 void *argp1 = 0 ;
32975 int res1 = 0 ;
32976 void *argp2 = 0 ;
32977 int res2 = 0 ;
32978 PyObject * obj0 = 0 ;
32979 PyObject * obj1 = 0 ;
32980 char * kwnames[] = {
32981 (char *) "self",(char *) "win", NULL
32982 };
32983
32984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32986 if (!SWIG_IsOK(res1)) {
32987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32988 }
32989 arg1 = reinterpret_cast< wxWindow * >(argp1);
32990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32991 if (!SWIG_IsOK(res2)) {
32992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32993 }
32994 arg2 = reinterpret_cast< wxWindow * >(argp2);
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 (arg1)->MoveBeforeInTabOrder(arg2);
32998 wxPyEndAllowThreads(__tstate);
32999 if (PyErr_Occurred()) SWIG_fail;
33000 }
33001 resultobj = SWIG_Py_Void();
33002 return resultobj;
33003 fail:
33004 return NULL;
33005 }
33006
33007
33008 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33009 PyObject *resultobj = 0;
33010 wxWindow *arg1 = (wxWindow *) 0 ;
33011 PyObject *result = 0 ;
33012 void *argp1 = 0 ;
33013 int res1 = 0 ;
33014 PyObject *swig_obj[1] ;
33015
33016 if (!args) SWIG_fail;
33017 swig_obj[0] = args;
33018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33019 if (!SWIG_IsOK(res1)) {
33020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33021 }
33022 arg1 = reinterpret_cast< wxWindow * >(argp1);
33023 {
33024 PyThreadState* __tstate = wxPyBeginAllowThreads();
33025 result = (PyObject *)wxWindow_GetChildren(arg1);
33026 wxPyEndAllowThreads(__tstate);
33027 if (PyErr_Occurred()) SWIG_fail;
33028 }
33029 resultobj = result;
33030 return resultobj;
33031 fail:
33032 return NULL;
33033 }
33034
33035
33036 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33037 PyObject *resultobj = 0;
33038 wxWindow *arg1 = (wxWindow *) 0 ;
33039 wxWindow *result = 0 ;
33040 void *argp1 = 0 ;
33041 int res1 = 0 ;
33042 PyObject *swig_obj[1] ;
33043
33044 if (!args) SWIG_fail;
33045 swig_obj[0] = args;
33046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33047 if (!SWIG_IsOK(res1)) {
33048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33049 }
33050 arg1 = reinterpret_cast< wxWindow * >(argp1);
33051 {
33052 PyThreadState* __tstate = wxPyBeginAllowThreads();
33053 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33054 wxPyEndAllowThreads(__tstate);
33055 if (PyErr_Occurred()) SWIG_fail;
33056 }
33057 {
33058 resultobj = wxPyMake_wxObject(result, 0);
33059 }
33060 return resultobj;
33061 fail:
33062 return NULL;
33063 }
33064
33065
33066 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33067 PyObject *resultobj = 0;
33068 wxWindow *arg1 = (wxWindow *) 0 ;
33069 wxWindow *result = 0 ;
33070 void *argp1 = 0 ;
33071 int res1 = 0 ;
33072 PyObject *swig_obj[1] ;
33073
33074 if (!args) SWIG_fail;
33075 swig_obj[0] = args;
33076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33077 if (!SWIG_IsOK(res1)) {
33078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33079 }
33080 arg1 = reinterpret_cast< wxWindow * >(argp1);
33081 {
33082 PyThreadState* __tstate = wxPyBeginAllowThreads();
33083 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 {
33088 resultobj = wxPyMake_wxObject(result, 0);
33089 }
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33097 PyObject *resultobj = 0;
33098 wxWindow *arg1 = (wxWindow *) 0 ;
33099 bool result;
33100 void *argp1 = 0 ;
33101 int res1 = 0 ;
33102 PyObject *swig_obj[1] ;
33103
33104 if (!args) SWIG_fail;
33105 swig_obj[0] = args;
33106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33107 if (!SWIG_IsOK(res1)) {
33108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33109 }
33110 arg1 = reinterpret_cast< wxWindow * >(argp1);
33111 {
33112 PyThreadState* __tstate = wxPyBeginAllowThreads();
33113 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33114 wxPyEndAllowThreads(__tstate);
33115 if (PyErr_Occurred()) SWIG_fail;
33116 }
33117 {
33118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33119 }
33120 return resultobj;
33121 fail:
33122 return NULL;
33123 }
33124
33125
33126 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33127 PyObject *resultobj = 0;
33128 wxWindow *arg1 = (wxWindow *) 0 ;
33129 wxWindow *arg2 = (wxWindow *) 0 ;
33130 bool result;
33131 void *argp1 = 0 ;
33132 int res1 = 0 ;
33133 void *argp2 = 0 ;
33134 int res2 = 0 ;
33135 PyObject * obj0 = 0 ;
33136 PyObject * obj1 = 0 ;
33137 char * kwnames[] = {
33138 (char *) "self",(char *) "newParent", NULL
33139 };
33140
33141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33143 if (!SWIG_IsOK(res1)) {
33144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33145 }
33146 arg1 = reinterpret_cast< wxWindow * >(argp1);
33147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33148 if (!SWIG_IsOK(res2)) {
33149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33150 }
33151 arg2 = reinterpret_cast< wxWindow * >(argp2);
33152 {
33153 PyThreadState* __tstate = wxPyBeginAllowThreads();
33154 result = (bool)(arg1)->Reparent(arg2);
33155 wxPyEndAllowThreads(__tstate);
33156 if (PyErr_Occurred()) SWIG_fail;
33157 }
33158 {
33159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33160 }
33161 return resultobj;
33162 fail:
33163 return NULL;
33164 }
33165
33166
33167 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33168 PyObject *resultobj = 0;
33169 wxWindow *arg1 = (wxWindow *) 0 ;
33170 wxWindow *arg2 = (wxWindow *) 0 ;
33171 void *argp1 = 0 ;
33172 int res1 = 0 ;
33173 void *argp2 = 0 ;
33174 int res2 = 0 ;
33175 PyObject * obj0 = 0 ;
33176 PyObject * obj1 = 0 ;
33177 char * kwnames[] = {
33178 (char *) "self",(char *) "child", NULL
33179 };
33180
33181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33183 if (!SWIG_IsOK(res1)) {
33184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33185 }
33186 arg1 = reinterpret_cast< wxWindow * >(argp1);
33187 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33188 if (!SWIG_IsOK(res2)) {
33189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33190 }
33191 arg2 = reinterpret_cast< wxWindow * >(argp2);
33192 {
33193 PyThreadState* __tstate = wxPyBeginAllowThreads();
33194 (arg1)->AddChild(arg2);
33195 wxPyEndAllowThreads(__tstate);
33196 if (PyErr_Occurred()) SWIG_fail;
33197 }
33198 resultobj = SWIG_Py_Void();
33199 return resultobj;
33200 fail:
33201 return NULL;
33202 }
33203
33204
33205 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33206 PyObject *resultobj = 0;
33207 wxWindow *arg1 = (wxWindow *) 0 ;
33208 wxWindow *arg2 = (wxWindow *) 0 ;
33209 void *argp1 = 0 ;
33210 int res1 = 0 ;
33211 void *argp2 = 0 ;
33212 int res2 = 0 ;
33213 PyObject * obj0 = 0 ;
33214 PyObject * obj1 = 0 ;
33215 char * kwnames[] = {
33216 (char *) "self",(char *) "child", NULL
33217 };
33218
33219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33221 if (!SWIG_IsOK(res1)) {
33222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33223 }
33224 arg1 = reinterpret_cast< wxWindow * >(argp1);
33225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33226 if (!SWIG_IsOK(res2)) {
33227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33228 }
33229 arg2 = reinterpret_cast< wxWindow * >(argp2);
33230 {
33231 PyThreadState* __tstate = wxPyBeginAllowThreads();
33232 (arg1)->RemoveChild(arg2);
33233 wxPyEndAllowThreads(__tstate);
33234 if (PyErr_Occurred()) SWIG_fail;
33235 }
33236 resultobj = SWIG_Py_Void();
33237 return resultobj;
33238 fail:
33239 return NULL;
33240 }
33241
33242
33243 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33244 PyObject *resultobj = 0;
33245 wxWindow *arg1 = (wxWindow *) 0 ;
33246 bool arg2 ;
33247 void *argp1 = 0 ;
33248 int res1 = 0 ;
33249 bool val2 ;
33250 int ecode2 = 0 ;
33251 PyObject * obj0 = 0 ;
33252 PyObject * obj1 = 0 ;
33253 char * kwnames[] = {
33254 (char *) "self",(char *) "on", NULL
33255 };
33256
33257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33259 if (!SWIG_IsOK(res1)) {
33260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33261 }
33262 arg1 = reinterpret_cast< wxWindow * >(argp1);
33263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33264 if (!SWIG_IsOK(ecode2)) {
33265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33266 }
33267 arg2 = static_cast< bool >(val2);
33268 {
33269 PyThreadState* __tstate = wxPyBeginAllowThreads();
33270 (arg1)->SetDoubleBuffered(arg2);
33271 wxPyEndAllowThreads(__tstate);
33272 if (PyErr_Occurred()) SWIG_fail;
33273 }
33274 resultobj = SWIG_Py_Void();
33275 return resultobj;
33276 fail:
33277 return NULL;
33278 }
33279
33280
33281 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33282 PyObject *resultobj = 0;
33283 wxWindow *arg1 = (wxWindow *) 0 ;
33284 long arg2 ;
33285 wxWindow *result = 0 ;
33286 void *argp1 = 0 ;
33287 int res1 = 0 ;
33288 long val2 ;
33289 int ecode2 = 0 ;
33290 PyObject * obj0 = 0 ;
33291 PyObject * obj1 = 0 ;
33292 char * kwnames[] = {
33293 (char *) "self",(char *) "winid", NULL
33294 };
33295
33296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33298 if (!SWIG_IsOK(res1)) {
33299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33300 }
33301 arg1 = reinterpret_cast< wxWindow * >(argp1);
33302 ecode2 = SWIG_AsVal_long(obj1, &val2);
33303 if (!SWIG_IsOK(ecode2)) {
33304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33305 }
33306 arg2 = static_cast< long >(val2);
33307 {
33308 PyThreadState* __tstate = wxPyBeginAllowThreads();
33309 result = (wxWindow *)(arg1)->FindWindow(arg2);
33310 wxPyEndAllowThreads(__tstate);
33311 if (PyErr_Occurred()) SWIG_fail;
33312 }
33313 {
33314 resultobj = wxPyMake_wxObject(result, 0);
33315 }
33316 return resultobj;
33317 fail:
33318 return NULL;
33319 }
33320
33321
33322 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33323 PyObject *resultobj = 0;
33324 wxWindow *arg1 = (wxWindow *) 0 ;
33325 wxString *arg2 = 0 ;
33326 wxWindow *result = 0 ;
33327 void *argp1 = 0 ;
33328 int res1 = 0 ;
33329 bool temp2 = false ;
33330 PyObject * obj0 = 0 ;
33331 PyObject * obj1 = 0 ;
33332 char * kwnames[] = {
33333 (char *) "self",(char *) "name", NULL
33334 };
33335
33336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33338 if (!SWIG_IsOK(res1)) {
33339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33340 }
33341 arg1 = reinterpret_cast< wxWindow * >(argp1);
33342 {
33343 arg2 = wxString_in_helper(obj1);
33344 if (arg2 == NULL) SWIG_fail;
33345 temp2 = true;
33346 }
33347 {
33348 PyThreadState* __tstate = wxPyBeginAllowThreads();
33349 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33350 wxPyEndAllowThreads(__tstate);
33351 if (PyErr_Occurred()) SWIG_fail;
33352 }
33353 {
33354 resultobj = wxPyMake_wxObject(result, 0);
33355 }
33356 {
33357 if (temp2)
33358 delete arg2;
33359 }
33360 return resultobj;
33361 fail:
33362 {
33363 if (temp2)
33364 delete arg2;
33365 }
33366 return NULL;
33367 }
33368
33369
33370 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33371 PyObject *resultobj = 0;
33372 wxWindow *arg1 = (wxWindow *) 0 ;
33373 wxEvtHandler *result = 0 ;
33374 void *argp1 = 0 ;
33375 int res1 = 0 ;
33376 PyObject *swig_obj[1] ;
33377
33378 if (!args) SWIG_fail;
33379 swig_obj[0] = args;
33380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33381 if (!SWIG_IsOK(res1)) {
33382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33383 }
33384 arg1 = reinterpret_cast< wxWindow * >(argp1);
33385 {
33386 PyThreadState* __tstate = wxPyBeginAllowThreads();
33387 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33388 wxPyEndAllowThreads(__tstate);
33389 if (PyErr_Occurred()) SWIG_fail;
33390 }
33391 {
33392 resultobj = wxPyMake_wxObject(result, 0);
33393 }
33394 return resultobj;
33395 fail:
33396 return NULL;
33397 }
33398
33399
33400 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33401 PyObject *resultobj = 0;
33402 wxWindow *arg1 = (wxWindow *) 0 ;
33403 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33404 void *argp1 = 0 ;
33405 int res1 = 0 ;
33406 void *argp2 = 0 ;
33407 int res2 = 0 ;
33408 PyObject * obj0 = 0 ;
33409 PyObject * obj1 = 0 ;
33410 char * kwnames[] = {
33411 (char *) "self",(char *) "handler", NULL
33412 };
33413
33414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33416 if (!SWIG_IsOK(res1)) {
33417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33418 }
33419 arg1 = reinterpret_cast< wxWindow * >(argp1);
33420 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33421 if (!SWIG_IsOK(res2)) {
33422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33423 }
33424 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 (arg1)->SetEventHandler(arg2);
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 resultobj = SWIG_Py_Void();
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33439 PyObject *resultobj = 0;
33440 wxWindow *arg1 = (wxWindow *) 0 ;
33441 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33442 void *argp1 = 0 ;
33443 int res1 = 0 ;
33444 void *argp2 = 0 ;
33445 int res2 = 0 ;
33446 PyObject * obj0 = 0 ;
33447 PyObject * obj1 = 0 ;
33448 char * kwnames[] = {
33449 (char *) "self",(char *) "handler", NULL
33450 };
33451
33452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33454 if (!SWIG_IsOK(res1)) {
33455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33456 }
33457 arg1 = reinterpret_cast< wxWindow * >(argp1);
33458 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33459 if (!SWIG_IsOK(res2)) {
33460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33461 }
33462 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33463 {
33464 PyThreadState* __tstate = wxPyBeginAllowThreads();
33465 (arg1)->PushEventHandler(arg2);
33466 wxPyEndAllowThreads(__tstate);
33467 if (PyErr_Occurred()) SWIG_fail;
33468 }
33469 resultobj = SWIG_Py_Void();
33470 return resultobj;
33471 fail:
33472 return NULL;
33473 }
33474
33475
33476 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33477 PyObject *resultobj = 0;
33478 wxWindow *arg1 = (wxWindow *) 0 ;
33479 bool arg2 = (bool) false ;
33480 wxEvtHandler *result = 0 ;
33481 void *argp1 = 0 ;
33482 int res1 = 0 ;
33483 bool val2 ;
33484 int ecode2 = 0 ;
33485 PyObject * obj0 = 0 ;
33486 PyObject * obj1 = 0 ;
33487 char * kwnames[] = {
33488 (char *) "self",(char *) "deleteHandler", NULL
33489 };
33490
33491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33493 if (!SWIG_IsOK(res1)) {
33494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33495 }
33496 arg1 = reinterpret_cast< wxWindow * >(argp1);
33497 if (obj1) {
33498 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33499 if (!SWIG_IsOK(ecode2)) {
33500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33501 }
33502 arg2 = static_cast< bool >(val2);
33503 }
33504 {
33505 PyThreadState* __tstate = wxPyBeginAllowThreads();
33506 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33507 wxPyEndAllowThreads(__tstate);
33508 if (PyErr_Occurred()) SWIG_fail;
33509 }
33510 {
33511 resultobj = wxPyMake_wxObject(result, 0);
33512 }
33513 return resultobj;
33514 fail:
33515 return NULL;
33516 }
33517
33518
33519 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33520 PyObject *resultobj = 0;
33521 wxWindow *arg1 = (wxWindow *) 0 ;
33522 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33523 bool result;
33524 void *argp1 = 0 ;
33525 int res1 = 0 ;
33526 void *argp2 = 0 ;
33527 int res2 = 0 ;
33528 PyObject * obj0 = 0 ;
33529 PyObject * obj1 = 0 ;
33530 char * kwnames[] = {
33531 (char *) "self",(char *) "handler", NULL
33532 };
33533
33534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33536 if (!SWIG_IsOK(res1)) {
33537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33538 }
33539 arg1 = reinterpret_cast< wxWindow * >(argp1);
33540 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33541 if (!SWIG_IsOK(res2)) {
33542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33543 }
33544 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 result = (bool)(arg1)->RemoveEventHandler(arg2);
33548 wxPyEndAllowThreads(__tstate);
33549 if (PyErr_Occurred()) SWIG_fail;
33550 }
33551 {
33552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33553 }
33554 return resultobj;
33555 fail:
33556 return NULL;
33557 }
33558
33559
33560 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33561 PyObject *resultobj = 0;
33562 wxWindow *arg1 = (wxWindow *) 0 ;
33563 wxValidator *arg2 = 0 ;
33564 void *argp1 = 0 ;
33565 int res1 = 0 ;
33566 void *argp2 = 0 ;
33567 int res2 = 0 ;
33568 PyObject * obj0 = 0 ;
33569 PyObject * obj1 = 0 ;
33570 char * kwnames[] = {
33571 (char *) "self",(char *) "validator", NULL
33572 };
33573
33574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33576 if (!SWIG_IsOK(res1)) {
33577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33578 }
33579 arg1 = reinterpret_cast< wxWindow * >(argp1);
33580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33581 if (!SWIG_IsOK(res2)) {
33582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33583 }
33584 if (!argp2) {
33585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33586 }
33587 arg2 = reinterpret_cast< wxValidator * >(argp2);
33588 {
33589 PyThreadState* __tstate = wxPyBeginAllowThreads();
33590 (arg1)->SetValidator((wxValidator const &)*arg2);
33591 wxPyEndAllowThreads(__tstate);
33592 if (PyErr_Occurred()) SWIG_fail;
33593 }
33594 resultobj = SWIG_Py_Void();
33595 return resultobj;
33596 fail:
33597 return NULL;
33598 }
33599
33600
33601 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33602 PyObject *resultobj = 0;
33603 wxWindow *arg1 = (wxWindow *) 0 ;
33604 wxValidator *result = 0 ;
33605 void *argp1 = 0 ;
33606 int res1 = 0 ;
33607 PyObject *swig_obj[1] ;
33608
33609 if (!args) SWIG_fail;
33610 swig_obj[0] = args;
33611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33612 if (!SWIG_IsOK(res1)) {
33613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33614 }
33615 arg1 = reinterpret_cast< wxWindow * >(argp1);
33616 {
33617 PyThreadState* __tstate = wxPyBeginAllowThreads();
33618 result = (wxValidator *)(arg1)->GetValidator();
33619 wxPyEndAllowThreads(__tstate);
33620 if (PyErr_Occurred()) SWIG_fail;
33621 }
33622 {
33623 resultobj = wxPyMake_wxObject(result, (bool)0);
33624 }
33625 return resultobj;
33626 fail:
33627 return NULL;
33628 }
33629
33630
33631 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33632 PyObject *resultobj = 0;
33633 wxWindow *arg1 = (wxWindow *) 0 ;
33634 bool result;
33635 void *argp1 = 0 ;
33636 int res1 = 0 ;
33637 PyObject *swig_obj[1] ;
33638
33639 if (!args) SWIG_fail;
33640 swig_obj[0] = args;
33641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33642 if (!SWIG_IsOK(res1)) {
33643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33644 }
33645 arg1 = reinterpret_cast< wxWindow * >(argp1);
33646 {
33647 PyThreadState* __tstate = wxPyBeginAllowThreads();
33648 result = (bool)(arg1)->Validate();
33649 wxPyEndAllowThreads(__tstate);
33650 if (PyErr_Occurred()) SWIG_fail;
33651 }
33652 {
33653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33654 }
33655 return resultobj;
33656 fail:
33657 return NULL;
33658 }
33659
33660
33661 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33662 PyObject *resultobj = 0;
33663 wxWindow *arg1 = (wxWindow *) 0 ;
33664 bool result;
33665 void *argp1 = 0 ;
33666 int res1 = 0 ;
33667 PyObject *swig_obj[1] ;
33668
33669 if (!args) SWIG_fail;
33670 swig_obj[0] = args;
33671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33672 if (!SWIG_IsOK(res1)) {
33673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33674 }
33675 arg1 = reinterpret_cast< wxWindow * >(argp1);
33676 {
33677 PyThreadState* __tstate = wxPyBeginAllowThreads();
33678 result = (bool)(arg1)->TransferDataToWindow();
33679 wxPyEndAllowThreads(__tstate);
33680 if (PyErr_Occurred()) SWIG_fail;
33681 }
33682 {
33683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33684 }
33685 return resultobj;
33686 fail:
33687 return NULL;
33688 }
33689
33690
33691 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33692 PyObject *resultobj = 0;
33693 wxWindow *arg1 = (wxWindow *) 0 ;
33694 bool result;
33695 void *argp1 = 0 ;
33696 int res1 = 0 ;
33697 PyObject *swig_obj[1] ;
33698
33699 if (!args) SWIG_fail;
33700 swig_obj[0] = args;
33701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33702 if (!SWIG_IsOK(res1)) {
33703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33704 }
33705 arg1 = reinterpret_cast< wxWindow * >(argp1);
33706 {
33707 PyThreadState* __tstate = wxPyBeginAllowThreads();
33708 result = (bool)(arg1)->TransferDataFromWindow();
33709 wxPyEndAllowThreads(__tstate);
33710 if (PyErr_Occurred()) SWIG_fail;
33711 }
33712 {
33713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33714 }
33715 return resultobj;
33716 fail:
33717 return NULL;
33718 }
33719
33720
33721 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33722 PyObject *resultobj = 0;
33723 wxWindow *arg1 = (wxWindow *) 0 ;
33724 void *argp1 = 0 ;
33725 int res1 = 0 ;
33726 PyObject *swig_obj[1] ;
33727
33728 if (!args) SWIG_fail;
33729 swig_obj[0] = args;
33730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33731 if (!SWIG_IsOK(res1)) {
33732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33733 }
33734 arg1 = reinterpret_cast< wxWindow * >(argp1);
33735 {
33736 PyThreadState* __tstate = wxPyBeginAllowThreads();
33737 (arg1)->InitDialog();
33738 wxPyEndAllowThreads(__tstate);
33739 if (PyErr_Occurred()) SWIG_fail;
33740 }
33741 resultobj = SWIG_Py_Void();
33742 return resultobj;
33743 fail:
33744 return NULL;
33745 }
33746
33747
33748 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33749 PyObject *resultobj = 0;
33750 wxWindow *arg1 = (wxWindow *) 0 ;
33751 wxAcceleratorTable *arg2 = 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 *) "accel", NULL
33760 };
33761
33762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",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_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33766 }
33767 arg1 = reinterpret_cast< wxWindow * >(argp1);
33768 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33769 if (!SWIG_IsOK(res2)) {
33770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33771 }
33772 if (!argp2) {
33773 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33774 }
33775 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33776 {
33777 PyThreadState* __tstate = wxPyBeginAllowThreads();
33778 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33779 wxPyEndAllowThreads(__tstate);
33780 if (PyErr_Occurred()) SWIG_fail;
33781 }
33782 resultobj = SWIG_Py_Void();
33783 return resultobj;
33784 fail:
33785 return NULL;
33786 }
33787
33788
33789 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33790 PyObject *resultobj = 0;
33791 wxWindow *arg1 = (wxWindow *) 0 ;
33792 wxAcceleratorTable *result = 0 ;
33793 void *argp1 = 0 ;
33794 int res1 = 0 ;
33795 PyObject *swig_obj[1] ;
33796
33797 if (!args) SWIG_fail;
33798 swig_obj[0] = args;
33799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33800 if (!SWIG_IsOK(res1)) {
33801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33802 }
33803 arg1 = reinterpret_cast< wxWindow * >(argp1);
33804 {
33805 PyThreadState* __tstate = wxPyBeginAllowThreads();
33806 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33807 wxPyEndAllowThreads(__tstate);
33808 if (PyErr_Occurred()) SWIG_fail;
33809 }
33810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33811 return resultobj;
33812 fail:
33813 return NULL;
33814 }
33815
33816
33817 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33818 PyObject *resultobj = 0;
33819 wxWindow *arg1 = (wxWindow *) 0 ;
33820 int arg2 ;
33821 int arg3 ;
33822 int arg4 ;
33823 bool result;
33824 void *argp1 = 0 ;
33825 int res1 = 0 ;
33826 int val2 ;
33827 int ecode2 = 0 ;
33828 int val3 ;
33829 int ecode3 = 0 ;
33830 int val4 ;
33831 int ecode4 = 0 ;
33832 PyObject * obj0 = 0 ;
33833 PyObject * obj1 = 0 ;
33834 PyObject * obj2 = 0 ;
33835 PyObject * obj3 = 0 ;
33836 char * kwnames[] = {
33837 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33838 };
33839
33840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33842 if (!SWIG_IsOK(res1)) {
33843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33844 }
33845 arg1 = reinterpret_cast< wxWindow * >(argp1);
33846 ecode2 = SWIG_AsVal_int(obj1, &val2);
33847 if (!SWIG_IsOK(ecode2)) {
33848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33849 }
33850 arg2 = static_cast< int >(val2);
33851 ecode3 = SWIG_AsVal_int(obj2, &val3);
33852 if (!SWIG_IsOK(ecode3)) {
33853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33854 }
33855 arg3 = static_cast< int >(val3);
33856 ecode4 = SWIG_AsVal_int(obj3, &val4);
33857 if (!SWIG_IsOK(ecode4)) {
33858 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33859 }
33860 arg4 = static_cast< int >(val4);
33861 {
33862 PyThreadState* __tstate = wxPyBeginAllowThreads();
33863 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33864 wxPyEndAllowThreads(__tstate);
33865 if (PyErr_Occurred()) SWIG_fail;
33866 }
33867 {
33868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33869 }
33870 return resultobj;
33871 fail:
33872 return NULL;
33873 }
33874
33875
33876 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33877 PyObject *resultobj = 0;
33878 wxWindow *arg1 = (wxWindow *) 0 ;
33879 int arg2 ;
33880 bool result;
33881 void *argp1 = 0 ;
33882 int res1 = 0 ;
33883 int val2 ;
33884 int ecode2 = 0 ;
33885 PyObject * obj0 = 0 ;
33886 PyObject * obj1 = 0 ;
33887 char * kwnames[] = {
33888 (char *) "self",(char *) "hotkeyId", NULL
33889 };
33890
33891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33893 if (!SWIG_IsOK(res1)) {
33894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33895 }
33896 arg1 = reinterpret_cast< wxWindow * >(argp1);
33897 ecode2 = SWIG_AsVal_int(obj1, &val2);
33898 if (!SWIG_IsOK(ecode2)) {
33899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33900 }
33901 arg2 = static_cast< int >(val2);
33902 {
33903 PyThreadState* __tstate = wxPyBeginAllowThreads();
33904 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33905 wxPyEndAllowThreads(__tstate);
33906 if (PyErr_Occurred()) SWIG_fail;
33907 }
33908 {
33909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33910 }
33911 return resultobj;
33912 fail:
33913 return NULL;
33914 }
33915
33916
33917 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33918 PyObject *resultobj = 0;
33919 wxWindow *arg1 = (wxWindow *) 0 ;
33920 wxPoint *arg2 = 0 ;
33921 wxPoint result;
33922 void *argp1 = 0 ;
33923 int res1 = 0 ;
33924 wxPoint temp2 ;
33925 PyObject * obj0 = 0 ;
33926 PyObject * obj1 = 0 ;
33927 char * kwnames[] = {
33928 (char *) "self",(char *) "pt", NULL
33929 };
33930
33931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33933 if (!SWIG_IsOK(res1)) {
33934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33935 }
33936 arg1 = reinterpret_cast< wxWindow * >(argp1);
33937 {
33938 arg2 = &temp2;
33939 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33940 }
33941 {
33942 PyThreadState* __tstate = wxPyBeginAllowThreads();
33943 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33944 wxPyEndAllowThreads(__tstate);
33945 if (PyErr_Occurred()) SWIG_fail;
33946 }
33947 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33948 return resultobj;
33949 fail:
33950 return NULL;
33951 }
33952
33953
33954 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33955 PyObject *resultobj = 0;
33956 wxWindow *arg1 = (wxWindow *) 0 ;
33957 wxSize *arg2 = 0 ;
33958 wxSize result;
33959 void *argp1 = 0 ;
33960 int res1 = 0 ;
33961 wxSize temp2 ;
33962 PyObject * obj0 = 0 ;
33963 PyObject * obj1 = 0 ;
33964 char * kwnames[] = {
33965 (char *) "self",(char *) "sz", NULL
33966 };
33967
33968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33970 if (!SWIG_IsOK(res1)) {
33971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33972 }
33973 arg1 = reinterpret_cast< wxWindow * >(argp1);
33974 {
33975 arg2 = &temp2;
33976 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33977 }
33978 {
33979 PyThreadState* __tstate = wxPyBeginAllowThreads();
33980 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33981 wxPyEndAllowThreads(__tstate);
33982 if (PyErr_Occurred()) SWIG_fail;
33983 }
33984 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33985 return resultobj;
33986 fail:
33987 return NULL;
33988 }
33989
33990
33991 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33992 PyObject *resultobj = 0;
33993 wxWindow *arg1 = (wxWindow *) 0 ;
33994 wxPoint *arg2 = 0 ;
33995 wxPoint result;
33996 void *argp1 = 0 ;
33997 int res1 = 0 ;
33998 wxPoint temp2 ;
33999 PyObject * obj0 = 0 ;
34000 PyObject * obj1 = 0 ;
34001 char * kwnames[] = {
34002 (char *) "self",(char *) "pt", NULL
34003 };
34004
34005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34007 if (!SWIG_IsOK(res1)) {
34008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34009 }
34010 arg1 = reinterpret_cast< wxWindow * >(argp1);
34011 {
34012 arg2 = &temp2;
34013 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34014 }
34015 {
34016 PyThreadState* __tstate = wxPyBeginAllowThreads();
34017 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34018 wxPyEndAllowThreads(__tstate);
34019 if (PyErr_Occurred()) SWIG_fail;
34020 }
34021 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34022 return resultobj;
34023 fail:
34024 return NULL;
34025 }
34026
34027
34028 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34029 PyObject *resultobj = 0;
34030 wxWindow *arg1 = (wxWindow *) 0 ;
34031 wxSize *arg2 = 0 ;
34032 wxSize result;
34033 void *argp1 = 0 ;
34034 int res1 = 0 ;
34035 wxSize temp2 ;
34036 PyObject * obj0 = 0 ;
34037 PyObject * obj1 = 0 ;
34038 char * kwnames[] = {
34039 (char *) "self",(char *) "sz", NULL
34040 };
34041
34042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34044 if (!SWIG_IsOK(res1)) {
34045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34046 }
34047 arg1 = reinterpret_cast< wxWindow * >(argp1);
34048 {
34049 arg2 = &temp2;
34050 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34051 }
34052 {
34053 PyThreadState* __tstate = wxPyBeginAllowThreads();
34054 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34055 wxPyEndAllowThreads(__tstate);
34056 if (PyErr_Occurred()) SWIG_fail;
34057 }
34058 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34059 return resultobj;
34060 fail:
34061 return NULL;
34062 }
34063
34064
34065 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34066 PyObject *resultobj = 0;
34067 wxWindow *arg1 = (wxWindow *) 0 ;
34068 wxPoint *arg2 = 0 ;
34069 wxPoint result;
34070 void *argp1 = 0 ;
34071 int res1 = 0 ;
34072 wxPoint temp2 ;
34073 PyObject * obj0 = 0 ;
34074 PyObject * obj1 = 0 ;
34075 char * kwnames[] = {
34076 (char *) "self",(char *) "pt", NULL
34077 };
34078
34079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34083 }
34084 arg1 = reinterpret_cast< wxWindow * >(argp1);
34085 {
34086 arg2 = &temp2;
34087 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34088 }
34089 {
34090 PyThreadState* __tstate = wxPyBeginAllowThreads();
34091 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34092 wxPyEndAllowThreads(__tstate);
34093 if (PyErr_Occurred()) SWIG_fail;
34094 }
34095 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34096 return resultobj;
34097 fail:
34098 return NULL;
34099 }
34100
34101
34102 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34103 PyObject *resultobj = 0;
34104 wxWindow *arg1 = (wxWindow *) 0 ;
34105 wxSize *arg2 = 0 ;
34106 wxSize result;
34107 void *argp1 = 0 ;
34108 int res1 = 0 ;
34109 wxSize temp2 ;
34110 PyObject * obj0 = 0 ;
34111 PyObject * obj1 = 0 ;
34112 char * kwnames[] = {
34113 (char *) "self",(char *) "sz", NULL
34114 };
34115
34116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34118 if (!SWIG_IsOK(res1)) {
34119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34120 }
34121 arg1 = reinterpret_cast< wxWindow * >(argp1);
34122 {
34123 arg2 = &temp2;
34124 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34125 }
34126 {
34127 PyThreadState* __tstate = wxPyBeginAllowThreads();
34128 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34129 wxPyEndAllowThreads(__tstate);
34130 if (PyErr_Occurred()) SWIG_fail;
34131 }
34132 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34133 return resultobj;
34134 fail:
34135 return NULL;
34136 }
34137
34138
34139 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34140 PyObject *resultobj = 0;
34141 wxWindow *arg1 = (wxWindow *) 0 ;
34142 int arg2 ;
34143 int arg3 ;
34144 void *argp1 = 0 ;
34145 int res1 = 0 ;
34146 int val2 ;
34147 int ecode2 = 0 ;
34148 int val3 ;
34149 int ecode3 = 0 ;
34150 PyObject * obj0 = 0 ;
34151 PyObject * obj1 = 0 ;
34152 PyObject * obj2 = 0 ;
34153 char * kwnames[] = {
34154 (char *) "self",(char *) "x",(char *) "y", NULL
34155 };
34156
34157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34159 if (!SWIG_IsOK(res1)) {
34160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34161 }
34162 arg1 = reinterpret_cast< wxWindow * >(argp1);
34163 ecode2 = SWIG_AsVal_int(obj1, &val2);
34164 if (!SWIG_IsOK(ecode2)) {
34165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34166 }
34167 arg2 = static_cast< int >(val2);
34168 ecode3 = SWIG_AsVal_int(obj2, &val3);
34169 if (!SWIG_IsOK(ecode3)) {
34170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34171 }
34172 arg3 = static_cast< int >(val3);
34173 {
34174 PyThreadState* __tstate = wxPyBeginAllowThreads();
34175 (arg1)->WarpPointer(arg2,arg3);
34176 wxPyEndAllowThreads(__tstate);
34177 if (PyErr_Occurred()) SWIG_fail;
34178 }
34179 resultobj = SWIG_Py_Void();
34180 return resultobj;
34181 fail:
34182 return NULL;
34183 }
34184
34185
34186 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34187 PyObject *resultobj = 0;
34188 wxWindow *arg1 = (wxWindow *) 0 ;
34189 void *argp1 = 0 ;
34190 int res1 = 0 ;
34191 PyObject *swig_obj[1] ;
34192
34193 if (!args) SWIG_fail;
34194 swig_obj[0] = args;
34195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34196 if (!SWIG_IsOK(res1)) {
34197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34198 }
34199 arg1 = reinterpret_cast< wxWindow * >(argp1);
34200 {
34201 PyThreadState* __tstate = wxPyBeginAllowThreads();
34202 (arg1)->CaptureMouse();
34203 wxPyEndAllowThreads(__tstate);
34204 if (PyErr_Occurred()) SWIG_fail;
34205 }
34206 resultobj = SWIG_Py_Void();
34207 return resultobj;
34208 fail:
34209 return NULL;
34210 }
34211
34212
34213 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34214 PyObject *resultobj = 0;
34215 wxWindow *arg1 = (wxWindow *) 0 ;
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_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34225 }
34226 arg1 = reinterpret_cast< wxWindow * >(argp1);
34227 {
34228 PyThreadState* __tstate = wxPyBeginAllowThreads();
34229 (arg1)->ReleaseMouse();
34230 wxPyEndAllowThreads(__tstate);
34231 if (PyErr_Occurred()) SWIG_fail;
34232 }
34233 resultobj = SWIG_Py_Void();
34234 return resultobj;
34235 fail:
34236 return NULL;
34237 }
34238
34239
34240 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34241 PyObject *resultobj = 0;
34242 wxWindow *result = 0 ;
34243
34244 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34245 {
34246 if (!wxPyCheckForApp()) SWIG_fail;
34247 PyThreadState* __tstate = wxPyBeginAllowThreads();
34248 result = (wxWindow *)wxWindow::GetCapture();
34249 wxPyEndAllowThreads(__tstate);
34250 if (PyErr_Occurred()) SWIG_fail;
34251 }
34252 {
34253 resultobj = wxPyMake_wxObject(result, 0);
34254 }
34255 return resultobj;
34256 fail:
34257 return NULL;
34258 }
34259
34260
34261 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34262 PyObject *resultobj = 0;
34263 wxWindow *arg1 = (wxWindow *) 0 ;
34264 bool result;
34265 void *argp1 = 0 ;
34266 int res1 = 0 ;
34267 PyObject *swig_obj[1] ;
34268
34269 if (!args) SWIG_fail;
34270 swig_obj[0] = args;
34271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34272 if (!SWIG_IsOK(res1)) {
34273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34274 }
34275 arg1 = reinterpret_cast< wxWindow * >(argp1);
34276 {
34277 PyThreadState* __tstate = wxPyBeginAllowThreads();
34278 result = (bool)((wxWindow const *)arg1)->HasCapture();
34279 wxPyEndAllowThreads(__tstate);
34280 if (PyErr_Occurred()) SWIG_fail;
34281 }
34282 {
34283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34284 }
34285 return resultobj;
34286 fail:
34287 return NULL;
34288 }
34289
34290
34291 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34292 PyObject *resultobj = 0;
34293 wxWindow *arg1 = (wxWindow *) 0 ;
34294 bool arg2 = (bool) true ;
34295 wxRect *arg3 = (wxRect *) NULL ;
34296 void *argp1 = 0 ;
34297 int res1 = 0 ;
34298 bool val2 ;
34299 int ecode2 = 0 ;
34300 void *argp3 = 0 ;
34301 int res3 = 0 ;
34302 PyObject * obj0 = 0 ;
34303 PyObject * obj1 = 0 ;
34304 PyObject * obj2 = 0 ;
34305 char * kwnames[] = {
34306 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34307 };
34308
34309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34311 if (!SWIG_IsOK(res1)) {
34312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34313 }
34314 arg1 = reinterpret_cast< wxWindow * >(argp1);
34315 if (obj1) {
34316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34317 if (!SWIG_IsOK(ecode2)) {
34318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34319 }
34320 arg2 = static_cast< bool >(val2);
34321 }
34322 if (obj2) {
34323 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34324 if (!SWIG_IsOK(res3)) {
34325 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34326 }
34327 arg3 = reinterpret_cast< wxRect * >(argp3);
34328 }
34329 {
34330 PyThreadState* __tstate = wxPyBeginAllowThreads();
34331 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34332 wxPyEndAllowThreads(__tstate);
34333 if (PyErr_Occurred()) SWIG_fail;
34334 }
34335 resultobj = SWIG_Py_Void();
34336 return resultobj;
34337 fail:
34338 return NULL;
34339 }
34340
34341
34342 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34343 PyObject *resultobj = 0;
34344 wxWindow *arg1 = (wxWindow *) 0 ;
34345 wxRect *arg2 = 0 ;
34346 bool arg3 = (bool) true ;
34347 void *argp1 = 0 ;
34348 int res1 = 0 ;
34349 wxRect temp2 ;
34350 bool val3 ;
34351 int ecode3 = 0 ;
34352 PyObject * obj0 = 0 ;
34353 PyObject * obj1 = 0 ;
34354 PyObject * obj2 = 0 ;
34355 char * kwnames[] = {
34356 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34357 };
34358
34359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34361 if (!SWIG_IsOK(res1)) {
34362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34363 }
34364 arg1 = reinterpret_cast< wxWindow * >(argp1);
34365 {
34366 arg2 = &temp2;
34367 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34368 }
34369 if (obj2) {
34370 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34371 if (!SWIG_IsOK(ecode3)) {
34372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34373 }
34374 arg3 = static_cast< bool >(val3);
34375 }
34376 {
34377 PyThreadState* __tstate = wxPyBeginAllowThreads();
34378 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34379 wxPyEndAllowThreads(__tstate);
34380 if (PyErr_Occurred()) SWIG_fail;
34381 }
34382 resultobj = SWIG_Py_Void();
34383 return resultobj;
34384 fail:
34385 return NULL;
34386 }
34387
34388
34389 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34390 PyObject *resultobj = 0;
34391 wxWindow *arg1 = (wxWindow *) 0 ;
34392 void *argp1 = 0 ;
34393 int res1 = 0 ;
34394 PyObject *swig_obj[1] ;
34395
34396 if (!args) SWIG_fail;
34397 swig_obj[0] = args;
34398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34399 if (!SWIG_IsOK(res1)) {
34400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34401 }
34402 arg1 = reinterpret_cast< wxWindow * >(argp1);
34403 {
34404 PyThreadState* __tstate = wxPyBeginAllowThreads();
34405 (arg1)->Update();
34406 wxPyEndAllowThreads(__tstate);
34407 if (PyErr_Occurred()) SWIG_fail;
34408 }
34409 resultobj = SWIG_Py_Void();
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34417 PyObject *resultobj = 0;
34418 wxWindow *arg1 = (wxWindow *) 0 ;
34419 void *argp1 = 0 ;
34420 int res1 = 0 ;
34421 PyObject *swig_obj[1] ;
34422
34423 if (!args) SWIG_fail;
34424 swig_obj[0] = args;
34425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34426 if (!SWIG_IsOK(res1)) {
34427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34428 }
34429 arg1 = reinterpret_cast< wxWindow * >(argp1);
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 (arg1)->ClearBackground();
34433 wxPyEndAllowThreads(__tstate);
34434 if (PyErr_Occurred()) SWIG_fail;
34435 }
34436 resultobj = SWIG_Py_Void();
34437 return resultobj;
34438 fail:
34439 return NULL;
34440 }
34441
34442
34443 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34444 PyObject *resultobj = 0;
34445 wxWindow *arg1 = (wxWindow *) 0 ;
34446 void *argp1 = 0 ;
34447 int res1 = 0 ;
34448 PyObject *swig_obj[1] ;
34449
34450 if (!args) SWIG_fail;
34451 swig_obj[0] = args;
34452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34453 if (!SWIG_IsOK(res1)) {
34454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34455 }
34456 arg1 = reinterpret_cast< wxWindow * >(argp1);
34457 {
34458 PyThreadState* __tstate = wxPyBeginAllowThreads();
34459 (arg1)->Freeze();
34460 wxPyEndAllowThreads(__tstate);
34461 if (PyErr_Occurred()) SWIG_fail;
34462 }
34463 resultobj = SWIG_Py_Void();
34464 return resultobj;
34465 fail:
34466 return NULL;
34467 }
34468
34469
34470 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34471 PyObject *resultobj = 0;
34472 wxWindow *arg1 = (wxWindow *) 0 ;
34473 void *argp1 = 0 ;
34474 int res1 = 0 ;
34475 PyObject *swig_obj[1] ;
34476
34477 if (!args) SWIG_fail;
34478 swig_obj[0] = args;
34479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34480 if (!SWIG_IsOK(res1)) {
34481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34482 }
34483 arg1 = reinterpret_cast< wxWindow * >(argp1);
34484 {
34485 PyThreadState* __tstate = wxPyBeginAllowThreads();
34486 (arg1)->Thaw();
34487 wxPyEndAllowThreads(__tstate);
34488 if (PyErr_Occurred()) SWIG_fail;
34489 }
34490 resultobj = SWIG_Py_Void();
34491 return resultobj;
34492 fail:
34493 return NULL;
34494 }
34495
34496
34497 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34498 PyObject *resultobj = 0;
34499 wxWindow *arg1 = (wxWindow *) 0 ;
34500 wxDC *arg2 = 0 ;
34501 void *argp1 = 0 ;
34502 int res1 = 0 ;
34503 void *argp2 = 0 ;
34504 int res2 = 0 ;
34505 PyObject * obj0 = 0 ;
34506 PyObject * obj1 = 0 ;
34507 char * kwnames[] = {
34508 (char *) "self",(char *) "dc", NULL
34509 };
34510
34511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34513 if (!SWIG_IsOK(res1)) {
34514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34515 }
34516 arg1 = reinterpret_cast< wxWindow * >(argp1);
34517 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34518 if (!SWIG_IsOK(res2)) {
34519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34520 }
34521 if (!argp2) {
34522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34523 }
34524 arg2 = reinterpret_cast< wxDC * >(argp2);
34525 {
34526 PyThreadState* __tstate = wxPyBeginAllowThreads();
34527 (arg1)->PrepareDC(*arg2);
34528 wxPyEndAllowThreads(__tstate);
34529 if (PyErr_Occurred()) SWIG_fail;
34530 }
34531 resultobj = SWIG_Py_Void();
34532 return resultobj;
34533 fail:
34534 return NULL;
34535 }
34536
34537
34538 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34539 PyObject *resultobj = 0;
34540 wxWindow *arg1 = (wxWindow *) 0 ;
34541 wxRegion *result = 0 ;
34542 void *argp1 = 0 ;
34543 int res1 = 0 ;
34544 PyObject *swig_obj[1] ;
34545
34546 if (!args) SWIG_fail;
34547 swig_obj[0] = args;
34548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34549 if (!SWIG_IsOK(res1)) {
34550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34551 }
34552 arg1 = reinterpret_cast< wxWindow * >(argp1);
34553 {
34554 PyThreadState* __tstate = wxPyBeginAllowThreads();
34555 {
34556 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34557 result = (wxRegion *) &_result_ref;
34558 }
34559 wxPyEndAllowThreads(__tstate);
34560 if (PyErr_Occurred()) SWIG_fail;
34561 }
34562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34563 return resultobj;
34564 fail:
34565 return NULL;
34566 }
34567
34568
34569 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34570 PyObject *resultobj = 0;
34571 wxWindow *arg1 = (wxWindow *) 0 ;
34572 wxRect result;
34573 void *argp1 = 0 ;
34574 int res1 = 0 ;
34575 PyObject *swig_obj[1] ;
34576
34577 if (!args) SWIG_fail;
34578 swig_obj[0] = args;
34579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34580 if (!SWIG_IsOK(res1)) {
34581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34582 }
34583 arg1 = reinterpret_cast< wxWindow * >(argp1);
34584 {
34585 PyThreadState* __tstate = wxPyBeginAllowThreads();
34586 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34587 wxPyEndAllowThreads(__tstate);
34588 if (PyErr_Occurred()) SWIG_fail;
34589 }
34590 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34591 return resultobj;
34592 fail:
34593 return NULL;
34594 }
34595
34596
34597 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34598 PyObject *resultobj = 0;
34599 wxWindow *arg1 = (wxWindow *) 0 ;
34600 int arg2 ;
34601 int arg3 ;
34602 int arg4 = (int) 1 ;
34603 int arg5 = (int) 1 ;
34604 bool result;
34605 void *argp1 = 0 ;
34606 int res1 = 0 ;
34607 int val2 ;
34608 int ecode2 = 0 ;
34609 int val3 ;
34610 int ecode3 = 0 ;
34611 int val4 ;
34612 int ecode4 = 0 ;
34613 int val5 ;
34614 int ecode5 = 0 ;
34615 PyObject * obj0 = 0 ;
34616 PyObject * obj1 = 0 ;
34617 PyObject * obj2 = 0 ;
34618 PyObject * obj3 = 0 ;
34619 PyObject * obj4 = 0 ;
34620 char * kwnames[] = {
34621 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34622 };
34623
34624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34626 if (!SWIG_IsOK(res1)) {
34627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34628 }
34629 arg1 = reinterpret_cast< wxWindow * >(argp1);
34630 ecode2 = SWIG_AsVal_int(obj1, &val2);
34631 if (!SWIG_IsOK(ecode2)) {
34632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34633 }
34634 arg2 = static_cast< int >(val2);
34635 ecode3 = SWIG_AsVal_int(obj2, &val3);
34636 if (!SWIG_IsOK(ecode3)) {
34637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34638 }
34639 arg3 = static_cast< int >(val3);
34640 if (obj3) {
34641 ecode4 = SWIG_AsVal_int(obj3, &val4);
34642 if (!SWIG_IsOK(ecode4)) {
34643 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34644 }
34645 arg4 = static_cast< int >(val4);
34646 }
34647 if (obj4) {
34648 ecode5 = SWIG_AsVal_int(obj4, &val5);
34649 if (!SWIG_IsOK(ecode5)) {
34650 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34651 }
34652 arg5 = static_cast< int >(val5);
34653 }
34654 {
34655 PyThreadState* __tstate = wxPyBeginAllowThreads();
34656 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34657 wxPyEndAllowThreads(__tstate);
34658 if (PyErr_Occurred()) SWIG_fail;
34659 }
34660 {
34661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34662 }
34663 return resultobj;
34664 fail:
34665 return NULL;
34666 }
34667
34668
34669 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34670 PyObject *resultobj = 0;
34671 wxWindow *arg1 = (wxWindow *) 0 ;
34672 wxPoint *arg2 = 0 ;
34673 bool result;
34674 void *argp1 = 0 ;
34675 int res1 = 0 ;
34676 wxPoint temp2 ;
34677 PyObject * obj0 = 0 ;
34678 PyObject * obj1 = 0 ;
34679 char * kwnames[] = {
34680 (char *) "self",(char *) "pt", NULL
34681 };
34682
34683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34685 if (!SWIG_IsOK(res1)) {
34686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34687 }
34688 arg1 = reinterpret_cast< wxWindow * >(argp1);
34689 {
34690 arg2 = &temp2;
34691 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34692 }
34693 {
34694 PyThreadState* __tstate = wxPyBeginAllowThreads();
34695 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34696 wxPyEndAllowThreads(__tstate);
34697 if (PyErr_Occurred()) SWIG_fail;
34698 }
34699 {
34700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34701 }
34702 return resultobj;
34703 fail:
34704 return NULL;
34705 }
34706
34707
34708 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34709 PyObject *resultobj = 0;
34710 wxWindow *arg1 = (wxWindow *) 0 ;
34711 wxRect *arg2 = 0 ;
34712 bool result;
34713 void *argp1 = 0 ;
34714 int res1 = 0 ;
34715 wxRect temp2 ;
34716 PyObject * obj0 = 0 ;
34717 PyObject * obj1 = 0 ;
34718 char * kwnames[] = {
34719 (char *) "self",(char *) "rect", NULL
34720 };
34721
34722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34724 if (!SWIG_IsOK(res1)) {
34725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34726 }
34727 arg1 = reinterpret_cast< wxWindow * >(argp1);
34728 {
34729 arg2 = &temp2;
34730 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34731 }
34732 {
34733 PyThreadState* __tstate = wxPyBeginAllowThreads();
34734 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34735 wxPyEndAllowThreads(__tstate);
34736 if (PyErr_Occurred()) SWIG_fail;
34737 }
34738 {
34739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34740 }
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34748 PyObject *resultobj = 0;
34749 wxWindow *arg1 = (wxWindow *) 0 ;
34750 SwigValueWrapper<wxVisualAttributes > result;
34751 void *argp1 = 0 ;
34752 int res1 = 0 ;
34753 PyObject *swig_obj[1] ;
34754
34755 if (!args) SWIG_fail;
34756 swig_obj[0] = args;
34757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34758 if (!SWIG_IsOK(res1)) {
34759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34760 }
34761 arg1 = reinterpret_cast< wxWindow * >(argp1);
34762 {
34763 PyThreadState* __tstate = wxPyBeginAllowThreads();
34764 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34776 PyObject *resultobj = 0;
34777 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34778 SwigValueWrapper<wxVisualAttributes > result;
34779 int val1 ;
34780 int ecode1 = 0 ;
34781 PyObject * obj0 = 0 ;
34782 char * kwnames[] = {
34783 (char *) "variant", NULL
34784 };
34785
34786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34787 if (obj0) {
34788 ecode1 = SWIG_AsVal_int(obj0, &val1);
34789 if (!SWIG_IsOK(ecode1)) {
34790 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34791 }
34792 arg1 = static_cast< wxWindowVariant >(val1);
34793 }
34794 {
34795 if (!wxPyCheckForApp()) SWIG_fail;
34796 PyThreadState* __tstate = wxPyBeginAllowThreads();
34797 result = wxWindow::GetClassDefaultAttributes(arg1);
34798 wxPyEndAllowThreads(__tstate);
34799 if (PyErr_Occurred()) SWIG_fail;
34800 }
34801 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34802 return resultobj;
34803 fail:
34804 return NULL;
34805 }
34806
34807
34808 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34809 PyObject *resultobj = 0;
34810 wxWindow *arg1 = (wxWindow *) 0 ;
34811 wxColour *arg2 = 0 ;
34812 bool result;
34813 void *argp1 = 0 ;
34814 int res1 = 0 ;
34815 wxColour temp2 ;
34816 PyObject * obj0 = 0 ;
34817 PyObject * obj1 = 0 ;
34818 char * kwnames[] = {
34819 (char *) "self",(char *) "colour", NULL
34820 };
34821
34822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34824 if (!SWIG_IsOK(res1)) {
34825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34826 }
34827 arg1 = reinterpret_cast< wxWindow * >(argp1);
34828 {
34829 arg2 = &temp2;
34830 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34831 }
34832 {
34833 PyThreadState* __tstate = wxPyBeginAllowThreads();
34834 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34835 wxPyEndAllowThreads(__tstate);
34836 if (PyErr_Occurred()) SWIG_fail;
34837 }
34838 {
34839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34840 }
34841 return resultobj;
34842 fail:
34843 return NULL;
34844 }
34845
34846
34847 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34848 PyObject *resultobj = 0;
34849 wxWindow *arg1 = (wxWindow *) 0 ;
34850 wxColour *arg2 = 0 ;
34851 void *argp1 = 0 ;
34852 int res1 = 0 ;
34853 wxColour temp2 ;
34854 PyObject * obj0 = 0 ;
34855 PyObject * obj1 = 0 ;
34856 char * kwnames[] = {
34857 (char *) "self",(char *) "colour", NULL
34858 };
34859
34860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34862 if (!SWIG_IsOK(res1)) {
34863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34864 }
34865 arg1 = reinterpret_cast< wxWindow * >(argp1);
34866 {
34867 arg2 = &temp2;
34868 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34869 }
34870 {
34871 PyThreadState* __tstate = wxPyBeginAllowThreads();
34872 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34873 wxPyEndAllowThreads(__tstate);
34874 if (PyErr_Occurred()) SWIG_fail;
34875 }
34876 resultobj = SWIG_Py_Void();
34877 return resultobj;
34878 fail:
34879 return NULL;
34880 }
34881
34882
34883 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34884 PyObject *resultobj = 0;
34885 wxWindow *arg1 = (wxWindow *) 0 ;
34886 wxColour *arg2 = 0 ;
34887 bool result;
34888 void *argp1 = 0 ;
34889 int res1 = 0 ;
34890 wxColour temp2 ;
34891 PyObject * obj0 = 0 ;
34892 PyObject * obj1 = 0 ;
34893 char * kwnames[] = {
34894 (char *) "self",(char *) "colour", NULL
34895 };
34896
34897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34899 if (!SWIG_IsOK(res1)) {
34900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34901 }
34902 arg1 = reinterpret_cast< wxWindow * >(argp1);
34903 {
34904 arg2 = &temp2;
34905 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34906 }
34907 {
34908 PyThreadState* __tstate = wxPyBeginAllowThreads();
34909 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34910 wxPyEndAllowThreads(__tstate);
34911 if (PyErr_Occurred()) SWIG_fail;
34912 }
34913 {
34914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34915 }
34916 return resultobj;
34917 fail:
34918 return NULL;
34919 }
34920
34921
34922 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34923 PyObject *resultobj = 0;
34924 wxWindow *arg1 = (wxWindow *) 0 ;
34925 wxColour *arg2 = 0 ;
34926 void *argp1 = 0 ;
34927 int res1 = 0 ;
34928 wxColour temp2 ;
34929 PyObject * obj0 = 0 ;
34930 PyObject * obj1 = 0 ;
34931 char * kwnames[] = {
34932 (char *) "self",(char *) "colour", NULL
34933 };
34934
34935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34937 if (!SWIG_IsOK(res1)) {
34938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34939 }
34940 arg1 = reinterpret_cast< wxWindow * >(argp1);
34941 {
34942 arg2 = &temp2;
34943 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34944 }
34945 {
34946 PyThreadState* __tstate = wxPyBeginAllowThreads();
34947 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34948 wxPyEndAllowThreads(__tstate);
34949 if (PyErr_Occurred()) SWIG_fail;
34950 }
34951 resultobj = SWIG_Py_Void();
34952 return resultobj;
34953 fail:
34954 return NULL;
34955 }
34956
34957
34958 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34959 PyObject *resultobj = 0;
34960 wxWindow *arg1 = (wxWindow *) 0 ;
34961 wxColour result;
34962 void *argp1 = 0 ;
34963 int res1 = 0 ;
34964 PyObject *swig_obj[1] ;
34965
34966 if (!args) SWIG_fail;
34967 swig_obj[0] = args;
34968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34969 if (!SWIG_IsOK(res1)) {
34970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34971 }
34972 arg1 = reinterpret_cast< wxWindow * >(argp1);
34973 {
34974 PyThreadState* __tstate = wxPyBeginAllowThreads();
34975 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34976 wxPyEndAllowThreads(__tstate);
34977 if (PyErr_Occurred()) SWIG_fail;
34978 }
34979 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34980 return resultobj;
34981 fail:
34982 return NULL;
34983 }
34984
34985
34986 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34987 PyObject *resultobj = 0;
34988 wxWindow *arg1 = (wxWindow *) 0 ;
34989 wxColour result;
34990 void *argp1 = 0 ;
34991 int res1 = 0 ;
34992 PyObject *swig_obj[1] ;
34993
34994 if (!args) SWIG_fail;
34995 swig_obj[0] = args;
34996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34997 if (!SWIG_IsOK(res1)) {
34998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34999 }
35000 arg1 = reinterpret_cast< wxWindow * >(argp1);
35001 {
35002 PyThreadState* __tstate = wxPyBeginAllowThreads();
35003 result = ((wxWindow const *)arg1)->GetForegroundColour();
35004 wxPyEndAllowThreads(__tstate);
35005 if (PyErr_Occurred()) SWIG_fail;
35006 }
35007 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35008 return resultobj;
35009 fail:
35010 return NULL;
35011 }
35012
35013
35014 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35015 PyObject *resultobj = 0;
35016 wxWindow *arg1 = (wxWindow *) 0 ;
35017 bool result;
35018 void *argp1 = 0 ;
35019 int res1 = 0 ;
35020 PyObject *swig_obj[1] ;
35021
35022 if (!args) SWIG_fail;
35023 swig_obj[0] = args;
35024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35025 if (!SWIG_IsOK(res1)) {
35026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35027 }
35028 arg1 = reinterpret_cast< wxWindow * >(argp1);
35029 {
35030 PyThreadState* __tstate = wxPyBeginAllowThreads();
35031 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35032 wxPyEndAllowThreads(__tstate);
35033 if (PyErr_Occurred()) SWIG_fail;
35034 }
35035 {
35036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35037 }
35038 return resultobj;
35039 fail:
35040 return NULL;
35041 }
35042
35043
35044 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35045 PyObject *resultobj = 0;
35046 wxWindow *arg1 = (wxWindow *) 0 ;
35047 bool result;
35048 void *argp1 = 0 ;
35049 int res1 = 0 ;
35050 PyObject *swig_obj[1] ;
35051
35052 if (!args) SWIG_fail;
35053 swig_obj[0] = args;
35054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35055 if (!SWIG_IsOK(res1)) {
35056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35057 }
35058 arg1 = reinterpret_cast< wxWindow * >(argp1);
35059 {
35060 PyThreadState* __tstate = wxPyBeginAllowThreads();
35061 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35062 wxPyEndAllowThreads(__tstate);
35063 if (PyErr_Occurred()) SWIG_fail;
35064 }
35065 {
35066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35067 }
35068 return resultobj;
35069 fail:
35070 return NULL;
35071 }
35072
35073
35074 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35075 PyObject *resultobj = 0;
35076 wxWindow *arg1 = (wxWindow *) 0 ;
35077 wxBackgroundStyle arg2 ;
35078 bool result;
35079 void *argp1 = 0 ;
35080 int res1 = 0 ;
35081 int val2 ;
35082 int ecode2 = 0 ;
35083 PyObject * obj0 = 0 ;
35084 PyObject * obj1 = 0 ;
35085 char * kwnames[] = {
35086 (char *) "self",(char *) "style", NULL
35087 };
35088
35089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35091 if (!SWIG_IsOK(res1)) {
35092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35093 }
35094 arg1 = reinterpret_cast< wxWindow * >(argp1);
35095 ecode2 = SWIG_AsVal_int(obj1, &val2);
35096 if (!SWIG_IsOK(ecode2)) {
35097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35098 }
35099 arg2 = static_cast< wxBackgroundStyle >(val2);
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 {
35107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35108 }
35109 return resultobj;
35110 fail:
35111 return NULL;
35112 }
35113
35114
35115 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35116 PyObject *resultobj = 0;
35117 wxWindow *arg1 = (wxWindow *) 0 ;
35118 wxBackgroundStyle result;
35119 void *argp1 = 0 ;
35120 int res1 = 0 ;
35121 PyObject *swig_obj[1] ;
35122
35123 if (!args) SWIG_fail;
35124 swig_obj[0] = args;
35125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35126 if (!SWIG_IsOK(res1)) {
35127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35128 }
35129 arg1 = reinterpret_cast< wxWindow * >(argp1);
35130 {
35131 PyThreadState* __tstate = wxPyBeginAllowThreads();
35132 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35133 wxPyEndAllowThreads(__tstate);
35134 if (PyErr_Occurred()) SWIG_fail;
35135 }
35136 resultobj = SWIG_From_int(static_cast< int >(result));
35137 return resultobj;
35138 fail:
35139 return NULL;
35140 }
35141
35142
35143 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35144 PyObject *resultobj = 0;
35145 wxWindow *arg1 = (wxWindow *) 0 ;
35146 bool result;
35147 void *argp1 = 0 ;
35148 int res1 = 0 ;
35149 PyObject *swig_obj[1] ;
35150
35151 if (!args) SWIG_fail;
35152 swig_obj[0] = args;
35153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35154 if (!SWIG_IsOK(res1)) {
35155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35156 }
35157 arg1 = reinterpret_cast< wxWindow * >(argp1);
35158 {
35159 PyThreadState* __tstate = wxPyBeginAllowThreads();
35160 result = (bool)(arg1)->HasTransparentBackground();
35161 wxPyEndAllowThreads(__tstate);
35162 if (PyErr_Occurred()) SWIG_fail;
35163 }
35164 {
35165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35166 }
35167 return resultobj;
35168 fail:
35169 return NULL;
35170 }
35171
35172
35173 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35174 PyObject *resultobj = 0;
35175 wxWindow *arg1 = (wxWindow *) 0 ;
35176 wxCursor *arg2 = 0 ;
35177 bool result;
35178 void *argp1 = 0 ;
35179 int res1 = 0 ;
35180 void *argp2 = 0 ;
35181 int res2 = 0 ;
35182 PyObject * obj0 = 0 ;
35183 PyObject * obj1 = 0 ;
35184 char * kwnames[] = {
35185 (char *) "self",(char *) "cursor", NULL
35186 };
35187
35188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35190 if (!SWIG_IsOK(res1)) {
35191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35192 }
35193 arg1 = reinterpret_cast< wxWindow * >(argp1);
35194 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35195 if (!SWIG_IsOK(res2)) {
35196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35197 }
35198 if (!argp2) {
35199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35200 }
35201 arg2 = reinterpret_cast< wxCursor * >(argp2);
35202 {
35203 PyThreadState* __tstate = wxPyBeginAllowThreads();
35204 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35205 wxPyEndAllowThreads(__tstate);
35206 if (PyErr_Occurred()) SWIG_fail;
35207 }
35208 {
35209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35210 }
35211 return resultobj;
35212 fail:
35213 return NULL;
35214 }
35215
35216
35217 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35218 PyObject *resultobj = 0;
35219 wxWindow *arg1 = (wxWindow *) 0 ;
35220 wxCursor result;
35221 void *argp1 = 0 ;
35222 int res1 = 0 ;
35223 PyObject *swig_obj[1] ;
35224
35225 if (!args) SWIG_fail;
35226 swig_obj[0] = args;
35227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35228 if (!SWIG_IsOK(res1)) {
35229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35230 }
35231 arg1 = reinterpret_cast< wxWindow * >(argp1);
35232 {
35233 PyThreadState* __tstate = wxPyBeginAllowThreads();
35234 result = (arg1)->GetCursor();
35235 wxPyEndAllowThreads(__tstate);
35236 if (PyErr_Occurred()) SWIG_fail;
35237 }
35238 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35239 return resultobj;
35240 fail:
35241 return NULL;
35242 }
35243
35244
35245 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35246 PyObject *resultobj = 0;
35247 wxWindow *arg1 = (wxWindow *) 0 ;
35248 wxFont *arg2 = 0 ;
35249 bool result;
35250 void *argp1 = 0 ;
35251 int res1 = 0 ;
35252 void *argp2 = 0 ;
35253 int res2 = 0 ;
35254 PyObject * obj0 = 0 ;
35255 PyObject * obj1 = 0 ;
35256 char * kwnames[] = {
35257 (char *) "self",(char *) "font", NULL
35258 };
35259
35260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35262 if (!SWIG_IsOK(res1)) {
35263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35264 }
35265 arg1 = reinterpret_cast< wxWindow * >(argp1);
35266 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35267 if (!SWIG_IsOK(res2)) {
35268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35269 }
35270 if (!argp2) {
35271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35272 }
35273 arg2 = reinterpret_cast< wxFont * >(argp2);
35274 {
35275 PyThreadState* __tstate = wxPyBeginAllowThreads();
35276 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35277 wxPyEndAllowThreads(__tstate);
35278 if (PyErr_Occurred()) SWIG_fail;
35279 }
35280 {
35281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35282 }
35283 return resultobj;
35284 fail:
35285 return NULL;
35286 }
35287
35288
35289 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35290 PyObject *resultobj = 0;
35291 wxWindow *arg1 = (wxWindow *) 0 ;
35292 wxFont *arg2 = 0 ;
35293 void *argp1 = 0 ;
35294 int res1 = 0 ;
35295 void *argp2 = 0 ;
35296 int res2 = 0 ;
35297 PyObject * obj0 = 0 ;
35298 PyObject * obj1 = 0 ;
35299 char * kwnames[] = {
35300 (char *) "self",(char *) "font", NULL
35301 };
35302
35303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35305 if (!SWIG_IsOK(res1)) {
35306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35307 }
35308 arg1 = reinterpret_cast< wxWindow * >(argp1);
35309 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35310 if (!SWIG_IsOK(res2)) {
35311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35312 }
35313 if (!argp2) {
35314 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35315 }
35316 arg2 = reinterpret_cast< wxFont * >(argp2);
35317 {
35318 PyThreadState* __tstate = wxPyBeginAllowThreads();
35319 (arg1)->SetOwnFont((wxFont const &)*arg2);
35320 wxPyEndAllowThreads(__tstate);
35321 if (PyErr_Occurred()) SWIG_fail;
35322 }
35323 resultobj = SWIG_Py_Void();
35324 return resultobj;
35325 fail:
35326 return NULL;
35327 }
35328
35329
35330 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35331 PyObject *resultobj = 0;
35332 wxWindow *arg1 = (wxWindow *) 0 ;
35333 wxFont result;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 PyObject *swig_obj[1] ;
35337
35338 if (!args) SWIG_fail;
35339 swig_obj[0] = args;
35340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35341 if (!SWIG_IsOK(res1)) {
35342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35343 }
35344 arg1 = reinterpret_cast< wxWindow * >(argp1);
35345 {
35346 PyThreadState* __tstate = wxPyBeginAllowThreads();
35347 result = (arg1)->GetFont();
35348 wxPyEndAllowThreads(__tstate);
35349 if (PyErr_Occurred()) SWIG_fail;
35350 }
35351 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35352 return resultobj;
35353 fail:
35354 return NULL;
35355 }
35356
35357
35358 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35359 PyObject *resultobj = 0;
35360 wxWindow *arg1 = (wxWindow *) 0 ;
35361 wxCaret *arg2 = (wxCaret *) 0 ;
35362 void *argp1 = 0 ;
35363 int res1 = 0 ;
35364 int res2 = 0 ;
35365 PyObject * obj0 = 0 ;
35366 PyObject * obj1 = 0 ;
35367 char * kwnames[] = {
35368 (char *) "self",(char *) "caret", NULL
35369 };
35370
35371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35373 if (!SWIG_IsOK(res1)) {
35374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35375 }
35376 arg1 = reinterpret_cast< wxWindow * >(argp1);
35377 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35378 if (!SWIG_IsOK(res2)) {
35379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35380 }
35381 {
35382 PyThreadState* __tstate = wxPyBeginAllowThreads();
35383 (arg1)->SetCaret(arg2);
35384 wxPyEndAllowThreads(__tstate);
35385 if (PyErr_Occurred()) SWIG_fail;
35386 }
35387 resultobj = SWIG_Py_Void();
35388 return resultobj;
35389 fail:
35390 return NULL;
35391 }
35392
35393
35394 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35395 PyObject *resultobj = 0;
35396 wxWindow *arg1 = (wxWindow *) 0 ;
35397 wxCaret *result = 0 ;
35398 void *argp1 = 0 ;
35399 int res1 = 0 ;
35400 PyObject *swig_obj[1] ;
35401
35402 if (!args) SWIG_fail;
35403 swig_obj[0] = args;
35404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35405 if (!SWIG_IsOK(res1)) {
35406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35407 }
35408 arg1 = reinterpret_cast< wxWindow * >(argp1);
35409 {
35410 PyThreadState* __tstate = wxPyBeginAllowThreads();
35411 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35412 wxPyEndAllowThreads(__tstate);
35413 if (PyErr_Occurred()) SWIG_fail;
35414 }
35415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35416 return resultobj;
35417 fail:
35418 return NULL;
35419 }
35420
35421
35422 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35423 PyObject *resultobj = 0;
35424 wxWindow *arg1 = (wxWindow *) 0 ;
35425 int result;
35426 void *argp1 = 0 ;
35427 int res1 = 0 ;
35428 PyObject *swig_obj[1] ;
35429
35430 if (!args) SWIG_fail;
35431 swig_obj[0] = args;
35432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35433 if (!SWIG_IsOK(res1)) {
35434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35435 }
35436 arg1 = reinterpret_cast< wxWindow * >(argp1);
35437 {
35438 PyThreadState* __tstate = wxPyBeginAllowThreads();
35439 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35440 wxPyEndAllowThreads(__tstate);
35441 if (PyErr_Occurred()) SWIG_fail;
35442 }
35443 resultobj = SWIG_From_int(static_cast< int >(result));
35444 return resultobj;
35445 fail:
35446 return NULL;
35447 }
35448
35449
35450 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35451 PyObject *resultobj = 0;
35452 wxWindow *arg1 = (wxWindow *) 0 ;
35453 int result;
35454 void *argp1 = 0 ;
35455 int res1 = 0 ;
35456 PyObject *swig_obj[1] ;
35457
35458 if (!args) SWIG_fail;
35459 swig_obj[0] = args;
35460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35461 if (!SWIG_IsOK(res1)) {
35462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35463 }
35464 arg1 = reinterpret_cast< wxWindow * >(argp1);
35465 {
35466 PyThreadState* __tstate = wxPyBeginAllowThreads();
35467 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35468 wxPyEndAllowThreads(__tstate);
35469 if (PyErr_Occurred()) SWIG_fail;
35470 }
35471 resultobj = SWIG_From_int(static_cast< int >(result));
35472 return resultobj;
35473 fail:
35474 return NULL;
35475 }
35476
35477
35478 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35479 PyObject *resultobj = 0;
35480 wxWindow *arg1 = (wxWindow *) 0 ;
35481 wxString *arg2 = 0 ;
35482 int *arg3 = (int *) 0 ;
35483 int *arg4 = (int *) 0 ;
35484 void *argp1 = 0 ;
35485 int res1 = 0 ;
35486 bool temp2 = false ;
35487 int temp3 ;
35488 int res3 = SWIG_TMPOBJ ;
35489 int temp4 ;
35490 int res4 = SWIG_TMPOBJ ;
35491 PyObject * obj0 = 0 ;
35492 PyObject * obj1 = 0 ;
35493 char * kwnames[] = {
35494 (char *) "self",(char *) "string", NULL
35495 };
35496
35497 arg3 = &temp3;
35498 arg4 = &temp4;
35499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35501 if (!SWIG_IsOK(res1)) {
35502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35503 }
35504 arg1 = reinterpret_cast< wxWindow * >(argp1);
35505 {
35506 arg2 = wxString_in_helper(obj1);
35507 if (arg2 == NULL) SWIG_fail;
35508 temp2 = true;
35509 }
35510 {
35511 PyThreadState* __tstate = wxPyBeginAllowThreads();
35512 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35513 wxPyEndAllowThreads(__tstate);
35514 if (PyErr_Occurred()) SWIG_fail;
35515 }
35516 resultobj = SWIG_Py_Void();
35517 if (SWIG_IsTmpObj(res3)) {
35518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35519 } else {
35520 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35522 }
35523 if (SWIG_IsTmpObj(res4)) {
35524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35525 } else {
35526 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35528 }
35529 {
35530 if (temp2)
35531 delete arg2;
35532 }
35533 return resultobj;
35534 fail:
35535 {
35536 if (temp2)
35537 delete arg2;
35538 }
35539 return NULL;
35540 }
35541
35542
35543 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35544 PyObject *resultobj = 0;
35545 wxWindow *arg1 = (wxWindow *) 0 ;
35546 wxString *arg2 = 0 ;
35547 int *arg3 = (int *) 0 ;
35548 int *arg4 = (int *) 0 ;
35549 int *arg5 = (int *) 0 ;
35550 int *arg6 = (int *) 0 ;
35551 wxFont *arg7 = (wxFont *) NULL ;
35552 void *argp1 = 0 ;
35553 int res1 = 0 ;
35554 bool temp2 = false ;
35555 int temp3 ;
35556 int res3 = SWIG_TMPOBJ ;
35557 int temp4 ;
35558 int res4 = SWIG_TMPOBJ ;
35559 int temp5 ;
35560 int res5 = SWIG_TMPOBJ ;
35561 int temp6 ;
35562 int res6 = SWIG_TMPOBJ ;
35563 void *argp7 = 0 ;
35564 int res7 = 0 ;
35565 PyObject * obj0 = 0 ;
35566 PyObject * obj1 = 0 ;
35567 PyObject * obj2 = 0 ;
35568 char * kwnames[] = {
35569 (char *) "self",(char *) "string",(char *) "font", NULL
35570 };
35571
35572 arg3 = &temp3;
35573 arg4 = &temp4;
35574 arg5 = &temp5;
35575 arg6 = &temp6;
35576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35578 if (!SWIG_IsOK(res1)) {
35579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35580 }
35581 arg1 = reinterpret_cast< wxWindow * >(argp1);
35582 {
35583 arg2 = wxString_in_helper(obj1);
35584 if (arg2 == NULL) SWIG_fail;
35585 temp2 = true;
35586 }
35587 if (obj2) {
35588 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35589 if (!SWIG_IsOK(res7)) {
35590 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35591 }
35592 arg7 = reinterpret_cast< wxFont * >(argp7);
35593 }
35594 {
35595 PyThreadState* __tstate = wxPyBeginAllowThreads();
35596 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35597 wxPyEndAllowThreads(__tstate);
35598 if (PyErr_Occurred()) SWIG_fail;
35599 }
35600 resultobj = SWIG_Py_Void();
35601 if (SWIG_IsTmpObj(res3)) {
35602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35603 } else {
35604 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35606 }
35607 if (SWIG_IsTmpObj(res4)) {
35608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35609 } else {
35610 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35612 }
35613 if (SWIG_IsTmpObj(res5)) {
35614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35615 } else {
35616 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35618 }
35619 if (SWIG_IsTmpObj(res6)) {
35620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35621 } else {
35622 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35624 }
35625 {
35626 if (temp2)
35627 delete arg2;
35628 }
35629 return resultobj;
35630 fail:
35631 {
35632 if (temp2)
35633 delete arg2;
35634 }
35635 return NULL;
35636 }
35637
35638
35639 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35640 PyObject *resultobj = 0;
35641 wxWindow *arg1 = (wxWindow *) 0 ;
35642 int *arg2 = (int *) 0 ;
35643 int *arg3 = (int *) 0 ;
35644 void *argp1 = 0 ;
35645 int res1 = 0 ;
35646 int temp2 ;
35647 int res2 = 0 ;
35648 int temp3 ;
35649 int res3 = 0 ;
35650 PyObject * obj0 = 0 ;
35651 PyObject * obj1 = 0 ;
35652 PyObject * obj2 = 0 ;
35653 char * kwnames[] = {
35654 (char *) "self",(char *) "x",(char *) "y", NULL
35655 };
35656
35657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35659 if (!SWIG_IsOK(res1)) {
35660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35661 }
35662 arg1 = reinterpret_cast< wxWindow * >(argp1);
35663 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35664 int val;
35665 int ecode = SWIG_AsVal_int(obj1, &val);
35666 if (!SWIG_IsOK(ecode)) {
35667 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35668 }
35669 temp2 = static_cast< int >(val);
35670 arg2 = &temp2;
35671 res2 = SWIG_AddTmpMask(ecode);
35672 }
35673 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35674 int val;
35675 int ecode = SWIG_AsVal_int(obj2, &val);
35676 if (!SWIG_IsOK(ecode)) {
35677 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35678 }
35679 temp3 = static_cast< int >(val);
35680 arg3 = &temp3;
35681 res3 = SWIG_AddTmpMask(ecode);
35682 }
35683 {
35684 PyThreadState* __tstate = wxPyBeginAllowThreads();
35685 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35686 wxPyEndAllowThreads(__tstate);
35687 if (PyErr_Occurred()) SWIG_fail;
35688 }
35689 resultobj = SWIG_Py_Void();
35690 if (SWIG_IsTmpObj(res2)) {
35691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35692 } else {
35693 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35695 }
35696 if (SWIG_IsTmpObj(res3)) {
35697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35698 } else {
35699 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35701 }
35702 return resultobj;
35703 fail:
35704 return NULL;
35705 }
35706
35707
35708 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35709 PyObject *resultobj = 0;
35710 wxWindow *arg1 = (wxWindow *) 0 ;
35711 int *arg2 = (int *) 0 ;
35712 int *arg3 = (int *) 0 ;
35713 void *argp1 = 0 ;
35714 int res1 = 0 ;
35715 int temp2 ;
35716 int res2 = 0 ;
35717 int temp3 ;
35718 int res3 = 0 ;
35719 PyObject * obj0 = 0 ;
35720 PyObject * obj1 = 0 ;
35721 PyObject * obj2 = 0 ;
35722 char * kwnames[] = {
35723 (char *) "self",(char *) "x",(char *) "y", NULL
35724 };
35725
35726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35728 if (!SWIG_IsOK(res1)) {
35729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35730 }
35731 arg1 = reinterpret_cast< wxWindow * >(argp1);
35732 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35733 int val;
35734 int ecode = SWIG_AsVal_int(obj1, &val);
35735 if (!SWIG_IsOK(ecode)) {
35736 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35737 }
35738 temp2 = static_cast< int >(val);
35739 arg2 = &temp2;
35740 res2 = SWIG_AddTmpMask(ecode);
35741 }
35742 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35743 int val;
35744 int ecode = SWIG_AsVal_int(obj2, &val);
35745 if (!SWIG_IsOK(ecode)) {
35746 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35747 }
35748 temp3 = static_cast< int >(val);
35749 arg3 = &temp3;
35750 res3 = SWIG_AddTmpMask(ecode);
35751 }
35752 {
35753 PyThreadState* __tstate = wxPyBeginAllowThreads();
35754 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35755 wxPyEndAllowThreads(__tstate);
35756 if (PyErr_Occurred()) SWIG_fail;
35757 }
35758 resultobj = SWIG_Py_Void();
35759 if (SWIG_IsTmpObj(res2)) {
35760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35761 } else {
35762 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35764 }
35765 if (SWIG_IsTmpObj(res3)) {
35766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35767 } else {
35768 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35770 }
35771 return resultobj;
35772 fail:
35773 return NULL;
35774 }
35775
35776
35777 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35778 PyObject *resultobj = 0;
35779 wxWindow *arg1 = (wxWindow *) 0 ;
35780 wxPoint *arg2 = 0 ;
35781 wxPoint result;
35782 void *argp1 = 0 ;
35783 int res1 = 0 ;
35784 wxPoint temp2 ;
35785 PyObject * obj0 = 0 ;
35786 PyObject * obj1 = 0 ;
35787 char * kwnames[] = {
35788 (char *) "self",(char *) "pt", NULL
35789 };
35790
35791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35793 if (!SWIG_IsOK(res1)) {
35794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35795 }
35796 arg1 = reinterpret_cast< wxWindow * >(argp1);
35797 {
35798 arg2 = &temp2;
35799 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35800 }
35801 {
35802 PyThreadState* __tstate = wxPyBeginAllowThreads();
35803 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35804 wxPyEndAllowThreads(__tstate);
35805 if (PyErr_Occurred()) SWIG_fail;
35806 }
35807 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35808 return resultobj;
35809 fail:
35810 return NULL;
35811 }
35812
35813
35814 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35815 PyObject *resultobj = 0;
35816 wxWindow *arg1 = (wxWindow *) 0 ;
35817 wxPoint *arg2 = 0 ;
35818 wxPoint result;
35819 void *argp1 = 0 ;
35820 int res1 = 0 ;
35821 wxPoint temp2 ;
35822 PyObject * obj0 = 0 ;
35823 PyObject * obj1 = 0 ;
35824 char * kwnames[] = {
35825 (char *) "self",(char *) "pt", NULL
35826 };
35827
35828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35830 if (!SWIG_IsOK(res1)) {
35831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35832 }
35833 arg1 = reinterpret_cast< wxWindow * >(argp1);
35834 {
35835 arg2 = &temp2;
35836 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35837 }
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35841 wxPyEndAllowThreads(__tstate);
35842 if (PyErr_Occurred()) SWIG_fail;
35843 }
35844 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35845 return resultobj;
35846 fail:
35847 return NULL;
35848 }
35849
35850
35851 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35852 PyObject *resultobj = 0;
35853 wxWindow *arg1 = (wxWindow *) 0 ;
35854 int arg2 ;
35855 int arg3 ;
35856 wxHitTest result;
35857 void *argp1 = 0 ;
35858 int res1 = 0 ;
35859 int val2 ;
35860 int ecode2 = 0 ;
35861 int val3 ;
35862 int ecode3 = 0 ;
35863 PyObject * obj0 = 0 ;
35864 PyObject * obj1 = 0 ;
35865 PyObject * obj2 = 0 ;
35866 char * kwnames[] = {
35867 (char *) "self",(char *) "x",(char *) "y", NULL
35868 };
35869
35870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35872 if (!SWIG_IsOK(res1)) {
35873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35874 }
35875 arg1 = reinterpret_cast< wxWindow * >(argp1);
35876 ecode2 = SWIG_AsVal_int(obj1, &val2);
35877 if (!SWIG_IsOK(ecode2)) {
35878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35879 }
35880 arg2 = static_cast< int >(val2);
35881 ecode3 = SWIG_AsVal_int(obj2, &val3);
35882 if (!SWIG_IsOK(ecode3)) {
35883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35884 }
35885 arg3 = static_cast< int >(val3);
35886 {
35887 PyThreadState* __tstate = wxPyBeginAllowThreads();
35888 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35889 wxPyEndAllowThreads(__tstate);
35890 if (PyErr_Occurred()) SWIG_fail;
35891 }
35892 resultobj = SWIG_From_int(static_cast< int >(result));
35893 return resultobj;
35894 fail:
35895 return NULL;
35896 }
35897
35898
35899 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35900 PyObject *resultobj = 0;
35901 wxWindow *arg1 = (wxWindow *) 0 ;
35902 wxPoint *arg2 = 0 ;
35903 wxHitTest result;
35904 void *argp1 = 0 ;
35905 int res1 = 0 ;
35906 wxPoint temp2 ;
35907 PyObject * obj0 = 0 ;
35908 PyObject * obj1 = 0 ;
35909 char * kwnames[] = {
35910 (char *) "self",(char *) "pt", NULL
35911 };
35912
35913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35915 if (!SWIG_IsOK(res1)) {
35916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35917 }
35918 arg1 = reinterpret_cast< wxWindow * >(argp1);
35919 {
35920 arg2 = &temp2;
35921 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35922 }
35923 {
35924 PyThreadState* __tstate = wxPyBeginAllowThreads();
35925 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35926 wxPyEndAllowThreads(__tstate);
35927 if (PyErr_Occurred()) SWIG_fail;
35928 }
35929 resultobj = SWIG_From_int(static_cast< int >(result));
35930 return resultobj;
35931 fail:
35932 return NULL;
35933 }
35934
35935
35936 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35937 PyObject *resultobj = 0;
35938 wxWindow *arg1 = (wxWindow *) 0 ;
35939 long arg2 ;
35940 wxBorder result;
35941 void *argp1 = 0 ;
35942 int res1 = 0 ;
35943 long val2 ;
35944 int ecode2 = 0 ;
35945
35946 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35948 if (!SWIG_IsOK(res1)) {
35949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35950 }
35951 arg1 = reinterpret_cast< wxWindow * >(argp1);
35952 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35953 if (!SWIG_IsOK(ecode2)) {
35954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35955 }
35956 arg2 = static_cast< long >(val2);
35957 {
35958 PyThreadState* __tstate = wxPyBeginAllowThreads();
35959 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35960 wxPyEndAllowThreads(__tstate);
35961 if (PyErr_Occurred()) SWIG_fail;
35962 }
35963 resultobj = SWIG_From_int(static_cast< int >(result));
35964 return resultobj;
35965 fail:
35966 return NULL;
35967 }
35968
35969
35970 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35971 PyObject *resultobj = 0;
35972 wxWindow *arg1 = (wxWindow *) 0 ;
35973 wxBorder result;
35974 void *argp1 = 0 ;
35975 int res1 = 0 ;
35976
35977 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35979 if (!SWIG_IsOK(res1)) {
35980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35981 }
35982 arg1 = reinterpret_cast< wxWindow * >(argp1);
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 resultobj = SWIG_From_int(static_cast< int >(result));
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35997 int argc;
35998 PyObject *argv[3];
35999
36000 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36001 --argc;
36002 if (argc == 1) {
36003 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36004 }
36005 if (argc == 2) {
36006 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36007 }
36008
36009 fail:
36010 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36011 return NULL;
36012 }
36013
36014
36015 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36016 PyObject *resultobj = 0;
36017 wxWindow *arg1 = (wxWindow *) 0 ;
36018 long arg2 = (long) wxUPDATE_UI_NONE ;
36019 void *argp1 = 0 ;
36020 int res1 = 0 ;
36021 long val2 ;
36022 int ecode2 = 0 ;
36023 PyObject * obj0 = 0 ;
36024 PyObject * obj1 = 0 ;
36025 char * kwnames[] = {
36026 (char *) "self",(char *) "flags", NULL
36027 };
36028
36029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36031 if (!SWIG_IsOK(res1)) {
36032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36033 }
36034 arg1 = reinterpret_cast< wxWindow * >(argp1);
36035 if (obj1) {
36036 ecode2 = SWIG_AsVal_long(obj1, &val2);
36037 if (!SWIG_IsOK(ecode2)) {
36038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36039 }
36040 arg2 = static_cast< long >(val2);
36041 }
36042 {
36043 PyThreadState* __tstate = wxPyBeginAllowThreads();
36044 (arg1)->UpdateWindowUI(arg2);
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 resultobj = SWIG_Py_Void();
36049 return resultobj;
36050 fail:
36051 return NULL;
36052 }
36053
36054
36055 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36056 PyObject *resultobj = 0;
36057 wxWindow *arg1 = (wxWindow *) 0 ;
36058 wxMenu *arg2 = (wxMenu *) 0 ;
36059 int arg3 = (int) -1 ;
36060 int arg4 = (int) -1 ;
36061 bool result;
36062 void *argp1 = 0 ;
36063 int res1 = 0 ;
36064 void *argp2 = 0 ;
36065 int res2 = 0 ;
36066 int val3 ;
36067 int ecode3 = 0 ;
36068 int val4 ;
36069 int ecode4 = 0 ;
36070 PyObject * obj0 = 0 ;
36071 PyObject * obj1 = 0 ;
36072 PyObject * obj2 = 0 ;
36073 PyObject * obj3 = 0 ;
36074 char * kwnames[] = {
36075 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36076 };
36077
36078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36080 if (!SWIG_IsOK(res1)) {
36081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36082 }
36083 arg1 = reinterpret_cast< wxWindow * >(argp1);
36084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36085 if (!SWIG_IsOK(res2)) {
36086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36087 }
36088 arg2 = reinterpret_cast< wxMenu * >(argp2);
36089 if (obj2) {
36090 ecode3 = SWIG_AsVal_int(obj2, &val3);
36091 if (!SWIG_IsOK(ecode3)) {
36092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36093 }
36094 arg3 = static_cast< int >(val3);
36095 }
36096 if (obj3) {
36097 ecode4 = SWIG_AsVal_int(obj3, &val4);
36098 if (!SWIG_IsOK(ecode4)) {
36099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36100 }
36101 arg4 = static_cast< int >(val4);
36102 }
36103 {
36104 PyThreadState* __tstate = wxPyBeginAllowThreads();
36105 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36106 wxPyEndAllowThreads(__tstate);
36107 if (PyErr_Occurred()) SWIG_fail;
36108 }
36109 {
36110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36111 }
36112 return resultobj;
36113 fail:
36114 return NULL;
36115 }
36116
36117
36118 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36119 PyObject *resultobj = 0;
36120 wxWindow *arg1 = (wxWindow *) 0 ;
36121 wxMenu *arg2 = (wxMenu *) 0 ;
36122 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36123 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36124 bool result;
36125 void *argp1 = 0 ;
36126 int res1 = 0 ;
36127 void *argp2 = 0 ;
36128 int res2 = 0 ;
36129 wxPoint temp3 ;
36130 PyObject * obj0 = 0 ;
36131 PyObject * obj1 = 0 ;
36132 PyObject * obj2 = 0 ;
36133 char * kwnames[] = {
36134 (char *) "self",(char *) "menu",(char *) "pos", NULL
36135 };
36136
36137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36139 if (!SWIG_IsOK(res1)) {
36140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36141 }
36142 arg1 = reinterpret_cast< wxWindow * >(argp1);
36143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36144 if (!SWIG_IsOK(res2)) {
36145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36146 }
36147 arg2 = reinterpret_cast< wxMenu * >(argp2);
36148 if (obj2) {
36149 {
36150 arg3 = &temp3;
36151 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36152 }
36153 }
36154 {
36155 PyThreadState* __tstate = wxPyBeginAllowThreads();
36156 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36157 wxPyEndAllowThreads(__tstate);
36158 if (PyErr_Occurred()) SWIG_fail;
36159 }
36160 {
36161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36162 }
36163 return resultobj;
36164 fail:
36165 return NULL;
36166 }
36167
36168
36169 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36170 PyObject *resultobj = 0;
36171 wxWindow *arg1 = (wxWindow *) 0 ;
36172 long result;
36173 void *argp1 = 0 ;
36174 int res1 = 0 ;
36175 PyObject *swig_obj[1] ;
36176
36177 if (!args) SWIG_fail;
36178 swig_obj[0] = args;
36179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36182 }
36183 arg1 = reinterpret_cast< wxWindow * >(argp1);
36184 {
36185 PyThreadState* __tstate = wxPyBeginAllowThreads();
36186 result = (long)wxWindow_GetHandle(arg1);
36187 wxPyEndAllowThreads(__tstate);
36188 if (PyErr_Occurred()) SWIG_fail;
36189 }
36190 resultobj = SWIG_From_long(static_cast< long >(result));
36191 return resultobj;
36192 fail:
36193 return NULL;
36194 }
36195
36196
36197 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36198 PyObject *resultobj = 0;
36199 wxWindow *arg1 = (wxWindow *) 0 ;
36200 long arg2 ;
36201 void *argp1 = 0 ;
36202 int res1 = 0 ;
36203 long val2 ;
36204 int ecode2 = 0 ;
36205 PyObject * obj0 = 0 ;
36206 PyObject * obj1 = 0 ;
36207 char * kwnames[] = {
36208 (char *) "self",(char *) "handle", NULL
36209 };
36210
36211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36213 if (!SWIG_IsOK(res1)) {
36214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36215 }
36216 arg1 = reinterpret_cast< wxWindow * >(argp1);
36217 ecode2 = SWIG_AsVal_long(obj1, &val2);
36218 if (!SWIG_IsOK(ecode2)) {
36219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36220 }
36221 arg2 = static_cast< long >(val2);
36222 {
36223 PyThreadState* __tstate = wxPyBeginAllowThreads();
36224 wxWindow_AssociateHandle(arg1,arg2);
36225 wxPyEndAllowThreads(__tstate);
36226 if (PyErr_Occurred()) SWIG_fail;
36227 }
36228 resultobj = SWIG_Py_Void();
36229 return resultobj;
36230 fail:
36231 return NULL;
36232 }
36233
36234
36235 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36236 PyObject *resultobj = 0;
36237 wxWindow *arg1 = (wxWindow *) 0 ;
36238 void *argp1 = 0 ;
36239 int res1 = 0 ;
36240 PyObject *swig_obj[1] ;
36241
36242 if (!args) SWIG_fail;
36243 swig_obj[0] = args;
36244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36245 if (!SWIG_IsOK(res1)) {
36246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36247 }
36248 arg1 = reinterpret_cast< wxWindow * >(argp1);
36249 {
36250 PyThreadState* __tstate = wxPyBeginAllowThreads();
36251 (arg1)->DissociateHandle();
36252 wxPyEndAllowThreads(__tstate);
36253 if (PyErr_Occurred()) SWIG_fail;
36254 }
36255 resultobj = SWIG_Py_Void();
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36263 PyObject *resultobj = 0;
36264 wxWindow *arg1 = (wxWindow *) 0 ;
36265 int arg2 ;
36266 bool result;
36267 void *argp1 = 0 ;
36268 int res1 = 0 ;
36269 int val2 ;
36270 int ecode2 = 0 ;
36271 PyObject * obj0 = 0 ;
36272 PyObject * obj1 = 0 ;
36273 char * kwnames[] = {
36274 (char *) "self",(char *) "orient", NULL
36275 };
36276
36277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36279 if (!SWIG_IsOK(res1)) {
36280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36281 }
36282 arg1 = reinterpret_cast< wxWindow * >(argp1);
36283 ecode2 = SWIG_AsVal_int(obj1, &val2);
36284 if (!SWIG_IsOK(ecode2)) {
36285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36286 }
36287 arg2 = static_cast< int >(val2);
36288 {
36289 PyThreadState* __tstate = wxPyBeginAllowThreads();
36290 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36291 wxPyEndAllowThreads(__tstate);
36292 if (PyErr_Occurred()) SWIG_fail;
36293 }
36294 {
36295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36296 }
36297 return resultobj;
36298 fail:
36299 return NULL;
36300 }
36301
36302
36303 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36304 PyObject *resultobj = 0;
36305 wxWindow *arg1 = (wxWindow *) 0 ;
36306 int arg2 ;
36307 int arg3 ;
36308 int arg4 ;
36309 int arg5 ;
36310 bool arg6 = (bool) true ;
36311 void *argp1 = 0 ;
36312 int res1 = 0 ;
36313 int val2 ;
36314 int ecode2 = 0 ;
36315 int val3 ;
36316 int ecode3 = 0 ;
36317 int val4 ;
36318 int ecode4 = 0 ;
36319 int val5 ;
36320 int ecode5 = 0 ;
36321 bool val6 ;
36322 int ecode6 = 0 ;
36323 PyObject * obj0 = 0 ;
36324 PyObject * obj1 = 0 ;
36325 PyObject * obj2 = 0 ;
36326 PyObject * obj3 = 0 ;
36327 PyObject * obj4 = 0 ;
36328 PyObject * obj5 = 0 ;
36329 char * kwnames[] = {
36330 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36331 };
36332
36333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36335 if (!SWIG_IsOK(res1)) {
36336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36337 }
36338 arg1 = reinterpret_cast< wxWindow * >(argp1);
36339 ecode2 = SWIG_AsVal_int(obj1, &val2);
36340 if (!SWIG_IsOK(ecode2)) {
36341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36342 }
36343 arg2 = static_cast< int >(val2);
36344 ecode3 = SWIG_AsVal_int(obj2, &val3);
36345 if (!SWIG_IsOK(ecode3)) {
36346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36347 }
36348 arg3 = static_cast< int >(val3);
36349 ecode4 = SWIG_AsVal_int(obj3, &val4);
36350 if (!SWIG_IsOK(ecode4)) {
36351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36352 }
36353 arg4 = static_cast< int >(val4);
36354 ecode5 = SWIG_AsVal_int(obj4, &val5);
36355 if (!SWIG_IsOK(ecode5)) {
36356 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36357 }
36358 arg5 = static_cast< int >(val5);
36359 if (obj5) {
36360 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36361 if (!SWIG_IsOK(ecode6)) {
36362 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36363 }
36364 arg6 = static_cast< bool >(val6);
36365 }
36366 {
36367 PyThreadState* __tstate = wxPyBeginAllowThreads();
36368 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36369 wxPyEndAllowThreads(__tstate);
36370 if (PyErr_Occurred()) SWIG_fail;
36371 }
36372 resultobj = SWIG_Py_Void();
36373 return resultobj;
36374 fail:
36375 return NULL;
36376 }
36377
36378
36379 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36380 PyObject *resultobj = 0;
36381 wxWindow *arg1 = (wxWindow *) 0 ;
36382 int arg2 ;
36383 int arg3 ;
36384 bool arg4 = (bool) true ;
36385 void *argp1 = 0 ;
36386 int res1 = 0 ;
36387 int val2 ;
36388 int ecode2 = 0 ;
36389 int val3 ;
36390 int ecode3 = 0 ;
36391 bool val4 ;
36392 int ecode4 = 0 ;
36393 PyObject * obj0 = 0 ;
36394 PyObject * obj1 = 0 ;
36395 PyObject * obj2 = 0 ;
36396 PyObject * obj3 = 0 ;
36397 char * kwnames[] = {
36398 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36399 };
36400
36401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36403 if (!SWIG_IsOK(res1)) {
36404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36405 }
36406 arg1 = reinterpret_cast< wxWindow * >(argp1);
36407 ecode2 = SWIG_AsVal_int(obj1, &val2);
36408 if (!SWIG_IsOK(ecode2)) {
36409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36410 }
36411 arg2 = static_cast< int >(val2);
36412 ecode3 = SWIG_AsVal_int(obj2, &val3);
36413 if (!SWIG_IsOK(ecode3)) {
36414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36415 }
36416 arg3 = static_cast< int >(val3);
36417 if (obj3) {
36418 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36419 if (!SWIG_IsOK(ecode4)) {
36420 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36421 }
36422 arg4 = static_cast< bool >(val4);
36423 }
36424 {
36425 PyThreadState* __tstate = wxPyBeginAllowThreads();
36426 (arg1)->SetScrollPos(arg2,arg3,arg4);
36427 wxPyEndAllowThreads(__tstate);
36428 if (PyErr_Occurred()) SWIG_fail;
36429 }
36430 resultobj = SWIG_Py_Void();
36431 return resultobj;
36432 fail:
36433 return NULL;
36434 }
36435
36436
36437 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36438 PyObject *resultobj = 0;
36439 wxWindow *arg1 = (wxWindow *) 0 ;
36440 int arg2 ;
36441 int result;
36442 void *argp1 = 0 ;
36443 int res1 = 0 ;
36444 int val2 ;
36445 int ecode2 = 0 ;
36446 PyObject * obj0 = 0 ;
36447 PyObject * obj1 = 0 ;
36448 char * kwnames[] = {
36449 (char *) "self",(char *) "orientation", NULL
36450 };
36451
36452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36454 if (!SWIG_IsOK(res1)) {
36455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36456 }
36457 arg1 = reinterpret_cast< wxWindow * >(argp1);
36458 ecode2 = SWIG_AsVal_int(obj1, &val2);
36459 if (!SWIG_IsOK(ecode2)) {
36460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36461 }
36462 arg2 = static_cast< int >(val2);
36463 {
36464 PyThreadState* __tstate = wxPyBeginAllowThreads();
36465 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36466 wxPyEndAllowThreads(__tstate);
36467 if (PyErr_Occurred()) SWIG_fail;
36468 }
36469 resultobj = SWIG_From_int(static_cast< int >(result));
36470 return resultobj;
36471 fail:
36472 return NULL;
36473 }
36474
36475
36476 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36477 PyObject *resultobj = 0;
36478 wxWindow *arg1 = (wxWindow *) 0 ;
36479 int arg2 ;
36480 int result;
36481 void *argp1 = 0 ;
36482 int res1 = 0 ;
36483 int val2 ;
36484 int ecode2 = 0 ;
36485 PyObject * obj0 = 0 ;
36486 PyObject * obj1 = 0 ;
36487 char * kwnames[] = {
36488 (char *) "self",(char *) "orientation", NULL
36489 };
36490
36491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36493 if (!SWIG_IsOK(res1)) {
36494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36495 }
36496 arg1 = reinterpret_cast< wxWindow * >(argp1);
36497 ecode2 = SWIG_AsVal_int(obj1, &val2);
36498 if (!SWIG_IsOK(ecode2)) {
36499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36500 }
36501 arg2 = static_cast< int >(val2);
36502 {
36503 PyThreadState* __tstate = wxPyBeginAllowThreads();
36504 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36505 wxPyEndAllowThreads(__tstate);
36506 if (PyErr_Occurred()) SWIG_fail;
36507 }
36508 resultobj = SWIG_From_int(static_cast< int >(result));
36509 return resultobj;
36510 fail:
36511 return NULL;
36512 }
36513
36514
36515 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36516 PyObject *resultobj = 0;
36517 wxWindow *arg1 = (wxWindow *) 0 ;
36518 int arg2 ;
36519 int result;
36520 void *argp1 = 0 ;
36521 int res1 = 0 ;
36522 int val2 ;
36523 int ecode2 = 0 ;
36524 PyObject * obj0 = 0 ;
36525 PyObject * obj1 = 0 ;
36526 char * kwnames[] = {
36527 (char *) "self",(char *) "orientation", NULL
36528 };
36529
36530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36532 if (!SWIG_IsOK(res1)) {
36533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36534 }
36535 arg1 = reinterpret_cast< wxWindow * >(argp1);
36536 ecode2 = SWIG_AsVal_int(obj1, &val2);
36537 if (!SWIG_IsOK(ecode2)) {
36538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36539 }
36540 arg2 = static_cast< int >(val2);
36541 {
36542 PyThreadState* __tstate = wxPyBeginAllowThreads();
36543 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36544 wxPyEndAllowThreads(__tstate);
36545 if (PyErr_Occurred()) SWIG_fail;
36546 }
36547 resultobj = SWIG_From_int(static_cast< int >(result));
36548 return resultobj;
36549 fail:
36550 return NULL;
36551 }
36552
36553
36554 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36555 PyObject *resultobj = 0;
36556 wxWindow *arg1 = (wxWindow *) 0 ;
36557 int arg2 ;
36558 int arg3 ;
36559 wxRect *arg4 = (wxRect *) NULL ;
36560 void *argp1 = 0 ;
36561 int res1 = 0 ;
36562 int val2 ;
36563 int ecode2 = 0 ;
36564 int val3 ;
36565 int ecode3 = 0 ;
36566 void *argp4 = 0 ;
36567 int res4 = 0 ;
36568 PyObject * obj0 = 0 ;
36569 PyObject * obj1 = 0 ;
36570 PyObject * obj2 = 0 ;
36571 PyObject * obj3 = 0 ;
36572 char * kwnames[] = {
36573 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36574 };
36575
36576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36578 if (!SWIG_IsOK(res1)) {
36579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36580 }
36581 arg1 = reinterpret_cast< wxWindow * >(argp1);
36582 ecode2 = SWIG_AsVal_int(obj1, &val2);
36583 if (!SWIG_IsOK(ecode2)) {
36584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36585 }
36586 arg2 = static_cast< int >(val2);
36587 ecode3 = SWIG_AsVal_int(obj2, &val3);
36588 if (!SWIG_IsOK(ecode3)) {
36589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36590 }
36591 arg3 = static_cast< int >(val3);
36592 if (obj3) {
36593 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36594 if (!SWIG_IsOK(res4)) {
36595 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36596 }
36597 arg4 = reinterpret_cast< wxRect * >(argp4);
36598 }
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36602 wxPyEndAllowThreads(__tstate);
36603 if (PyErr_Occurred()) SWIG_fail;
36604 }
36605 resultobj = SWIG_Py_Void();
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36613 PyObject *resultobj = 0;
36614 wxWindow *arg1 = (wxWindow *) 0 ;
36615 int arg2 ;
36616 bool result;
36617 void *argp1 = 0 ;
36618 int res1 = 0 ;
36619 int val2 ;
36620 int ecode2 = 0 ;
36621 PyObject * obj0 = 0 ;
36622 PyObject * obj1 = 0 ;
36623 char * kwnames[] = {
36624 (char *) "self",(char *) "lines", NULL
36625 };
36626
36627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36629 if (!SWIG_IsOK(res1)) {
36630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36631 }
36632 arg1 = reinterpret_cast< wxWindow * >(argp1);
36633 ecode2 = SWIG_AsVal_int(obj1, &val2);
36634 if (!SWIG_IsOK(ecode2)) {
36635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36636 }
36637 arg2 = static_cast< int >(val2);
36638 {
36639 PyThreadState* __tstate = wxPyBeginAllowThreads();
36640 result = (bool)(arg1)->ScrollLines(arg2);
36641 wxPyEndAllowThreads(__tstate);
36642 if (PyErr_Occurred()) SWIG_fail;
36643 }
36644 {
36645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36646 }
36647 return resultobj;
36648 fail:
36649 return NULL;
36650 }
36651
36652
36653 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36654 PyObject *resultobj = 0;
36655 wxWindow *arg1 = (wxWindow *) 0 ;
36656 int arg2 ;
36657 bool result;
36658 void *argp1 = 0 ;
36659 int res1 = 0 ;
36660 int val2 ;
36661 int ecode2 = 0 ;
36662 PyObject * obj0 = 0 ;
36663 PyObject * obj1 = 0 ;
36664 char * kwnames[] = {
36665 (char *) "self",(char *) "pages", NULL
36666 };
36667
36668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36670 if (!SWIG_IsOK(res1)) {
36671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36672 }
36673 arg1 = reinterpret_cast< wxWindow * >(argp1);
36674 ecode2 = SWIG_AsVal_int(obj1, &val2);
36675 if (!SWIG_IsOK(ecode2)) {
36676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36677 }
36678 arg2 = static_cast< int >(val2);
36679 {
36680 PyThreadState* __tstate = wxPyBeginAllowThreads();
36681 result = (bool)(arg1)->ScrollPages(arg2);
36682 wxPyEndAllowThreads(__tstate);
36683 if (PyErr_Occurred()) SWIG_fail;
36684 }
36685 {
36686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36687 }
36688 return resultobj;
36689 fail:
36690 return NULL;
36691 }
36692
36693
36694 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36695 PyObject *resultobj = 0;
36696 wxWindow *arg1 = (wxWindow *) 0 ;
36697 bool result;
36698 void *argp1 = 0 ;
36699 int res1 = 0 ;
36700 PyObject *swig_obj[1] ;
36701
36702 if (!args) SWIG_fail;
36703 swig_obj[0] = args;
36704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36705 if (!SWIG_IsOK(res1)) {
36706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36707 }
36708 arg1 = reinterpret_cast< wxWindow * >(argp1);
36709 {
36710 PyThreadState* __tstate = wxPyBeginAllowThreads();
36711 result = (bool)(arg1)->LineUp();
36712 wxPyEndAllowThreads(__tstate);
36713 if (PyErr_Occurred()) SWIG_fail;
36714 }
36715 {
36716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36717 }
36718 return resultobj;
36719 fail:
36720 return NULL;
36721 }
36722
36723
36724 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36725 PyObject *resultobj = 0;
36726 wxWindow *arg1 = (wxWindow *) 0 ;
36727 bool result;
36728 void *argp1 = 0 ;
36729 int res1 = 0 ;
36730 PyObject *swig_obj[1] ;
36731
36732 if (!args) SWIG_fail;
36733 swig_obj[0] = args;
36734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36735 if (!SWIG_IsOK(res1)) {
36736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36737 }
36738 arg1 = reinterpret_cast< wxWindow * >(argp1);
36739 {
36740 PyThreadState* __tstate = wxPyBeginAllowThreads();
36741 result = (bool)(arg1)->LineDown();
36742 wxPyEndAllowThreads(__tstate);
36743 if (PyErr_Occurred()) SWIG_fail;
36744 }
36745 {
36746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36747 }
36748 return resultobj;
36749 fail:
36750 return NULL;
36751 }
36752
36753
36754 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36755 PyObject *resultobj = 0;
36756 wxWindow *arg1 = (wxWindow *) 0 ;
36757 bool result;
36758 void *argp1 = 0 ;
36759 int res1 = 0 ;
36760 PyObject *swig_obj[1] ;
36761
36762 if (!args) SWIG_fail;
36763 swig_obj[0] = args;
36764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36765 if (!SWIG_IsOK(res1)) {
36766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36767 }
36768 arg1 = reinterpret_cast< wxWindow * >(argp1);
36769 {
36770 PyThreadState* __tstate = wxPyBeginAllowThreads();
36771 result = (bool)(arg1)->PageUp();
36772 wxPyEndAllowThreads(__tstate);
36773 if (PyErr_Occurred()) SWIG_fail;
36774 }
36775 {
36776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36777 }
36778 return resultobj;
36779 fail:
36780 return NULL;
36781 }
36782
36783
36784 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36785 PyObject *resultobj = 0;
36786 wxWindow *arg1 = (wxWindow *) 0 ;
36787 bool result;
36788 void *argp1 = 0 ;
36789 int res1 = 0 ;
36790 PyObject *swig_obj[1] ;
36791
36792 if (!args) SWIG_fail;
36793 swig_obj[0] = args;
36794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36795 if (!SWIG_IsOK(res1)) {
36796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36797 }
36798 arg1 = reinterpret_cast< wxWindow * >(argp1);
36799 {
36800 PyThreadState* __tstate = wxPyBeginAllowThreads();
36801 result = (bool)(arg1)->PageDown();
36802 wxPyEndAllowThreads(__tstate);
36803 if (PyErr_Occurred()) SWIG_fail;
36804 }
36805 {
36806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36807 }
36808 return resultobj;
36809 fail:
36810 return NULL;
36811 }
36812
36813
36814 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36815 PyObject *resultobj = 0;
36816 wxWindow *arg1 = (wxWindow *) 0 ;
36817 wxString *arg2 = 0 ;
36818 void *argp1 = 0 ;
36819 int res1 = 0 ;
36820 bool temp2 = false ;
36821 PyObject * obj0 = 0 ;
36822 PyObject * obj1 = 0 ;
36823 char * kwnames[] = {
36824 (char *) "self",(char *) "text", NULL
36825 };
36826
36827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36829 if (!SWIG_IsOK(res1)) {
36830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36831 }
36832 arg1 = reinterpret_cast< wxWindow * >(argp1);
36833 {
36834 arg2 = wxString_in_helper(obj1);
36835 if (arg2 == NULL) SWIG_fail;
36836 temp2 = true;
36837 }
36838 {
36839 PyThreadState* __tstate = wxPyBeginAllowThreads();
36840 (arg1)->SetHelpText((wxString const &)*arg2);
36841 wxPyEndAllowThreads(__tstate);
36842 if (PyErr_Occurred()) SWIG_fail;
36843 }
36844 resultobj = SWIG_Py_Void();
36845 {
36846 if (temp2)
36847 delete arg2;
36848 }
36849 return resultobj;
36850 fail:
36851 {
36852 if (temp2)
36853 delete arg2;
36854 }
36855 return NULL;
36856 }
36857
36858
36859 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36860 PyObject *resultobj = 0;
36861 wxWindow *arg1 = (wxWindow *) 0 ;
36862 wxString *arg2 = 0 ;
36863 void *argp1 = 0 ;
36864 int res1 = 0 ;
36865 bool temp2 = false ;
36866 PyObject * obj0 = 0 ;
36867 PyObject * obj1 = 0 ;
36868 char * kwnames[] = {
36869 (char *) "self",(char *) "text", NULL
36870 };
36871
36872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36874 if (!SWIG_IsOK(res1)) {
36875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36876 }
36877 arg1 = reinterpret_cast< wxWindow * >(argp1);
36878 {
36879 arg2 = wxString_in_helper(obj1);
36880 if (arg2 == NULL) SWIG_fail;
36881 temp2 = true;
36882 }
36883 {
36884 PyThreadState* __tstate = wxPyBeginAllowThreads();
36885 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36886 wxPyEndAllowThreads(__tstate);
36887 if (PyErr_Occurred()) SWIG_fail;
36888 }
36889 resultobj = SWIG_Py_Void();
36890 {
36891 if (temp2)
36892 delete arg2;
36893 }
36894 return resultobj;
36895 fail:
36896 {
36897 if (temp2)
36898 delete arg2;
36899 }
36900 return NULL;
36901 }
36902
36903
36904 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36905 PyObject *resultobj = 0;
36906 wxWindow *arg1 = (wxWindow *) 0 ;
36907 wxPoint *arg2 = 0 ;
36908 wxHelpEvent::Origin arg3 ;
36909 wxString result;
36910 void *argp1 = 0 ;
36911 int res1 = 0 ;
36912 wxPoint temp2 ;
36913 void *argp3 ;
36914 int res3 = 0 ;
36915 PyObject * obj0 = 0 ;
36916 PyObject * obj1 = 0 ;
36917 PyObject * obj2 = 0 ;
36918 char * kwnames[] = {
36919 (char *) "self",(char *) "pt",(char *) "origin", NULL
36920 };
36921
36922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36924 if (!SWIG_IsOK(res1)) {
36925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36926 }
36927 arg1 = reinterpret_cast< wxWindow * >(argp1);
36928 {
36929 arg2 = &temp2;
36930 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36931 }
36932 {
36933 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36934 if (!SWIG_IsOK(res3)) {
36935 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36936 }
36937 if (!argp3) {
36938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36939 } else {
36940 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
36941 arg3 = *temp;
36942 if (SWIG_IsNewObj(res3)) delete temp;
36943 }
36944 }
36945 {
36946 PyThreadState* __tstate = wxPyBeginAllowThreads();
36947 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
36948 wxPyEndAllowThreads(__tstate);
36949 if (PyErr_Occurred()) SWIG_fail;
36950 }
36951 {
36952 #if wxUSE_UNICODE
36953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36954 #else
36955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36956 #endif
36957 }
36958 return resultobj;
36959 fail:
36960 return NULL;
36961 }
36962
36963
36964 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36965 PyObject *resultobj = 0;
36966 wxWindow *arg1 = (wxWindow *) 0 ;
36967 wxString result;
36968 void *argp1 = 0 ;
36969 int res1 = 0 ;
36970 PyObject *swig_obj[1] ;
36971
36972 if (!args) SWIG_fail;
36973 swig_obj[0] = args;
36974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36975 if (!SWIG_IsOK(res1)) {
36976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36977 }
36978 arg1 = reinterpret_cast< wxWindow * >(argp1);
36979 {
36980 PyThreadState* __tstate = wxPyBeginAllowThreads();
36981 result = ((wxWindow const *)arg1)->GetHelpText();
36982 wxPyEndAllowThreads(__tstate);
36983 if (PyErr_Occurred()) SWIG_fail;
36984 }
36985 {
36986 #if wxUSE_UNICODE
36987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36988 #else
36989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36990 #endif
36991 }
36992 return resultobj;
36993 fail:
36994 return NULL;
36995 }
36996
36997
36998 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36999 PyObject *resultobj = 0;
37000 wxWindow *arg1 = (wxWindow *) 0 ;
37001 wxString *arg2 = 0 ;
37002 void *argp1 = 0 ;
37003 int res1 = 0 ;
37004 bool temp2 = false ;
37005 PyObject * obj0 = 0 ;
37006 PyObject * obj1 = 0 ;
37007 char * kwnames[] = {
37008 (char *) "self",(char *) "tip", NULL
37009 };
37010
37011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37013 if (!SWIG_IsOK(res1)) {
37014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37015 }
37016 arg1 = reinterpret_cast< wxWindow * >(argp1);
37017 {
37018 arg2 = wxString_in_helper(obj1);
37019 if (arg2 == NULL) SWIG_fail;
37020 temp2 = true;
37021 }
37022 {
37023 PyThreadState* __tstate = wxPyBeginAllowThreads();
37024 (arg1)->SetToolTip((wxString const &)*arg2);
37025 wxPyEndAllowThreads(__tstate);
37026 if (PyErr_Occurred()) SWIG_fail;
37027 }
37028 resultobj = SWIG_Py_Void();
37029 {
37030 if (temp2)
37031 delete arg2;
37032 }
37033 return resultobj;
37034 fail:
37035 {
37036 if (temp2)
37037 delete arg2;
37038 }
37039 return NULL;
37040 }
37041
37042
37043 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37044 PyObject *resultobj = 0;
37045 wxWindow *arg1 = (wxWindow *) 0 ;
37046 wxToolTip *arg2 = (wxToolTip *) 0 ;
37047 void *argp1 = 0 ;
37048 int res1 = 0 ;
37049 int res2 = 0 ;
37050 PyObject * obj0 = 0 ;
37051 PyObject * obj1 = 0 ;
37052 char * kwnames[] = {
37053 (char *) "self",(char *) "tip", NULL
37054 };
37055
37056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37058 if (!SWIG_IsOK(res1)) {
37059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37060 }
37061 arg1 = reinterpret_cast< wxWindow * >(argp1);
37062 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37063 if (!SWIG_IsOK(res2)) {
37064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37065 }
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 (arg1)->SetToolTip(arg2);
37069 wxPyEndAllowThreads(__tstate);
37070 if (PyErr_Occurred()) SWIG_fail;
37071 }
37072 resultobj = SWIG_Py_Void();
37073 return resultobj;
37074 fail:
37075 return NULL;
37076 }
37077
37078
37079 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37080 PyObject *resultobj = 0;
37081 wxWindow *arg1 = (wxWindow *) 0 ;
37082 wxToolTip *result = 0 ;
37083 void *argp1 = 0 ;
37084 int res1 = 0 ;
37085 PyObject *swig_obj[1] ;
37086
37087 if (!args) SWIG_fail;
37088 swig_obj[0] = args;
37089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37090 if (!SWIG_IsOK(res1)) {
37091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37092 }
37093 arg1 = reinterpret_cast< wxWindow * >(argp1);
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 {
37101 resultobj = wxPyMake_wxObject(result, (bool)0);
37102 }
37103 return resultobj;
37104 fail:
37105 return NULL;
37106 }
37107
37108
37109 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37110 PyObject *resultobj = 0;
37111 wxWindow *arg1 = (wxWindow *) 0 ;
37112 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37113 void *argp1 = 0 ;
37114 int res1 = 0 ;
37115 int res2 = 0 ;
37116 PyObject * obj0 = 0 ;
37117 PyObject * obj1 = 0 ;
37118 char * kwnames[] = {
37119 (char *) "self",(char *) "dropTarget", NULL
37120 };
37121
37122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37124 if (!SWIG_IsOK(res1)) {
37125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37126 }
37127 arg1 = reinterpret_cast< wxWindow * >(argp1);
37128 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37129 if (!SWIG_IsOK(res2)) {
37130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37131 }
37132 {
37133 PyThreadState* __tstate = wxPyBeginAllowThreads();
37134 (arg1)->SetDropTarget(arg2);
37135 wxPyEndAllowThreads(__tstate);
37136 if (PyErr_Occurred()) SWIG_fail;
37137 }
37138 resultobj = SWIG_Py_Void();
37139 return resultobj;
37140 fail:
37141 return NULL;
37142 }
37143
37144
37145 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37146 PyObject *resultobj = 0;
37147 wxWindow *arg1 = (wxWindow *) 0 ;
37148 wxPyDropTarget *result = 0 ;
37149 void *argp1 = 0 ;
37150 int res1 = 0 ;
37151 PyObject *swig_obj[1] ;
37152
37153 if (!args) SWIG_fail;
37154 swig_obj[0] = args;
37155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37156 if (!SWIG_IsOK(res1)) {
37157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37158 }
37159 arg1 = reinterpret_cast< wxWindow * >(argp1);
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37163 wxPyEndAllowThreads(__tstate);
37164 if (PyErr_Occurred()) SWIG_fail;
37165 }
37166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37167 return resultobj;
37168 fail:
37169 return NULL;
37170 }
37171
37172
37173 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37174 PyObject *resultobj = 0;
37175 wxWindow *arg1 = (wxWindow *) 0 ;
37176 bool arg2 ;
37177 void *argp1 = 0 ;
37178 int res1 = 0 ;
37179 bool val2 ;
37180 int ecode2 = 0 ;
37181 PyObject * obj0 = 0 ;
37182 PyObject * obj1 = 0 ;
37183 char * kwnames[] = {
37184 (char *) "self",(char *) "accept", NULL
37185 };
37186
37187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37189 if (!SWIG_IsOK(res1)) {
37190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37191 }
37192 arg1 = reinterpret_cast< wxWindow * >(argp1);
37193 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37194 if (!SWIG_IsOK(ecode2)) {
37195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37196 }
37197 arg2 = static_cast< bool >(val2);
37198 {
37199 PyThreadState* __tstate = wxPyBeginAllowThreads();
37200 wxWindow_DragAcceptFiles(arg1,arg2);
37201 wxPyEndAllowThreads(__tstate);
37202 if (PyErr_Occurred()) SWIG_fail;
37203 }
37204 resultobj = SWIG_Py_Void();
37205 return resultobj;
37206 fail:
37207 return NULL;
37208 }
37209
37210
37211 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37212 PyObject *resultobj = 0;
37213 wxWindow *arg1 = (wxWindow *) 0 ;
37214 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37215 void *argp1 = 0 ;
37216 int res1 = 0 ;
37217 int res2 = 0 ;
37218 PyObject * obj0 = 0 ;
37219 PyObject * obj1 = 0 ;
37220 char * kwnames[] = {
37221 (char *) "self",(char *) "constraints", NULL
37222 };
37223
37224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37226 if (!SWIG_IsOK(res1)) {
37227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37228 }
37229 arg1 = reinterpret_cast< wxWindow * >(argp1);
37230 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37231 if (!SWIG_IsOK(res2)) {
37232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37233 }
37234 {
37235 PyThreadState* __tstate = wxPyBeginAllowThreads();
37236 (arg1)->SetConstraints(arg2);
37237 wxPyEndAllowThreads(__tstate);
37238 if (PyErr_Occurred()) SWIG_fail;
37239 }
37240 resultobj = SWIG_Py_Void();
37241 return resultobj;
37242 fail:
37243 return NULL;
37244 }
37245
37246
37247 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37248 PyObject *resultobj = 0;
37249 wxWindow *arg1 = (wxWindow *) 0 ;
37250 wxLayoutConstraints *result = 0 ;
37251 void *argp1 = 0 ;
37252 int res1 = 0 ;
37253 PyObject *swig_obj[1] ;
37254
37255 if (!args) SWIG_fail;
37256 swig_obj[0] = args;
37257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37258 if (!SWIG_IsOK(res1)) {
37259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37260 }
37261 arg1 = reinterpret_cast< wxWindow * >(argp1);
37262 {
37263 PyThreadState* __tstate = wxPyBeginAllowThreads();
37264 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37265 wxPyEndAllowThreads(__tstate);
37266 if (PyErr_Occurred()) SWIG_fail;
37267 }
37268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37269 return resultobj;
37270 fail:
37271 return NULL;
37272 }
37273
37274
37275 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37276 PyObject *resultobj = 0;
37277 wxWindow *arg1 = (wxWindow *) 0 ;
37278 bool arg2 ;
37279 void *argp1 = 0 ;
37280 int res1 = 0 ;
37281 bool val2 ;
37282 int ecode2 = 0 ;
37283 PyObject * obj0 = 0 ;
37284 PyObject * obj1 = 0 ;
37285 char * kwnames[] = {
37286 (char *) "self",(char *) "autoLayout", NULL
37287 };
37288
37289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37291 if (!SWIG_IsOK(res1)) {
37292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37293 }
37294 arg1 = reinterpret_cast< wxWindow * >(argp1);
37295 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37296 if (!SWIG_IsOK(ecode2)) {
37297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37298 }
37299 arg2 = static_cast< bool >(val2);
37300 {
37301 PyThreadState* __tstate = wxPyBeginAllowThreads();
37302 (arg1)->SetAutoLayout(arg2);
37303 wxPyEndAllowThreads(__tstate);
37304 if (PyErr_Occurred()) SWIG_fail;
37305 }
37306 resultobj = SWIG_Py_Void();
37307 return resultobj;
37308 fail:
37309 return NULL;
37310 }
37311
37312
37313 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37314 PyObject *resultobj = 0;
37315 wxWindow *arg1 = (wxWindow *) 0 ;
37316 bool result;
37317 void *argp1 = 0 ;
37318 int res1 = 0 ;
37319 PyObject *swig_obj[1] ;
37320
37321 if (!args) SWIG_fail;
37322 swig_obj[0] = args;
37323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37324 if (!SWIG_IsOK(res1)) {
37325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37326 }
37327 arg1 = reinterpret_cast< wxWindow * >(argp1);
37328 {
37329 PyThreadState* __tstate = wxPyBeginAllowThreads();
37330 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37331 wxPyEndAllowThreads(__tstate);
37332 if (PyErr_Occurred()) SWIG_fail;
37333 }
37334 {
37335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37336 }
37337 return resultobj;
37338 fail:
37339 return NULL;
37340 }
37341
37342
37343 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37344 PyObject *resultobj = 0;
37345 wxWindow *arg1 = (wxWindow *) 0 ;
37346 bool result;
37347 void *argp1 = 0 ;
37348 int res1 = 0 ;
37349 PyObject *swig_obj[1] ;
37350
37351 if (!args) SWIG_fail;
37352 swig_obj[0] = args;
37353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37354 if (!SWIG_IsOK(res1)) {
37355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37356 }
37357 arg1 = reinterpret_cast< wxWindow * >(argp1);
37358 {
37359 PyThreadState* __tstate = wxPyBeginAllowThreads();
37360 result = (bool)(arg1)->Layout();
37361 wxPyEndAllowThreads(__tstate);
37362 if (PyErr_Occurred()) SWIG_fail;
37363 }
37364 {
37365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37366 }
37367 return resultobj;
37368 fail:
37369 return NULL;
37370 }
37371
37372
37373 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37374 PyObject *resultobj = 0;
37375 wxWindow *arg1 = (wxWindow *) 0 ;
37376 wxSizer *arg2 = (wxSizer *) 0 ;
37377 bool arg3 = (bool) true ;
37378 void *argp1 = 0 ;
37379 int res1 = 0 ;
37380 int res2 = 0 ;
37381 bool val3 ;
37382 int ecode3 = 0 ;
37383 PyObject * obj0 = 0 ;
37384 PyObject * obj1 = 0 ;
37385 PyObject * obj2 = 0 ;
37386 char * kwnames[] = {
37387 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37388 };
37389
37390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37392 if (!SWIG_IsOK(res1)) {
37393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37394 }
37395 arg1 = reinterpret_cast< wxWindow * >(argp1);
37396 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37397 if (!SWIG_IsOK(res2)) {
37398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37399 }
37400 if (obj2) {
37401 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37402 if (!SWIG_IsOK(ecode3)) {
37403 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37404 }
37405 arg3 = static_cast< bool >(val3);
37406 }
37407 {
37408 PyThreadState* __tstate = wxPyBeginAllowThreads();
37409 (arg1)->SetSizer(arg2,arg3);
37410 wxPyEndAllowThreads(__tstate);
37411 if (PyErr_Occurred()) SWIG_fail;
37412 }
37413 resultobj = SWIG_Py_Void();
37414 return resultobj;
37415 fail:
37416 return NULL;
37417 }
37418
37419
37420 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37421 PyObject *resultobj = 0;
37422 wxWindow *arg1 = (wxWindow *) 0 ;
37423 wxSizer *arg2 = (wxSizer *) 0 ;
37424 bool arg3 = (bool) true ;
37425 void *argp1 = 0 ;
37426 int res1 = 0 ;
37427 int res2 = 0 ;
37428 bool val3 ;
37429 int ecode3 = 0 ;
37430 PyObject * obj0 = 0 ;
37431 PyObject * obj1 = 0 ;
37432 PyObject * obj2 = 0 ;
37433 char * kwnames[] = {
37434 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37435 };
37436
37437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37439 if (!SWIG_IsOK(res1)) {
37440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37441 }
37442 arg1 = reinterpret_cast< wxWindow * >(argp1);
37443 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37444 if (!SWIG_IsOK(res2)) {
37445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37446 }
37447 if (obj2) {
37448 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37449 if (!SWIG_IsOK(ecode3)) {
37450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37451 }
37452 arg3 = static_cast< bool >(val3);
37453 }
37454 {
37455 PyThreadState* __tstate = wxPyBeginAllowThreads();
37456 (arg1)->SetSizerAndFit(arg2,arg3);
37457 wxPyEndAllowThreads(__tstate);
37458 if (PyErr_Occurred()) SWIG_fail;
37459 }
37460 resultobj = SWIG_Py_Void();
37461 return resultobj;
37462 fail:
37463 return NULL;
37464 }
37465
37466
37467 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37468 PyObject *resultobj = 0;
37469 wxWindow *arg1 = (wxWindow *) 0 ;
37470 wxSizer *result = 0 ;
37471 void *argp1 = 0 ;
37472 int res1 = 0 ;
37473 PyObject *swig_obj[1] ;
37474
37475 if (!args) SWIG_fail;
37476 swig_obj[0] = args;
37477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37478 if (!SWIG_IsOK(res1)) {
37479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37480 }
37481 arg1 = reinterpret_cast< wxWindow * >(argp1);
37482 {
37483 PyThreadState* __tstate = wxPyBeginAllowThreads();
37484 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37485 wxPyEndAllowThreads(__tstate);
37486 if (PyErr_Occurred()) SWIG_fail;
37487 }
37488 {
37489 resultobj = wxPyMake_wxObject(result, (bool)0);
37490 }
37491 return resultobj;
37492 fail:
37493 return NULL;
37494 }
37495
37496
37497 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37498 PyObject *resultobj = 0;
37499 wxWindow *arg1 = (wxWindow *) 0 ;
37500 wxSizer *arg2 = (wxSizer *) 0 ;
37501 void *argp1 = 0 ;
37502 int res1 = 0 ;
37503 void *argp2 = 0 ;
37504 int res2 = 0 ;
37505 PyObject * obj0 = 0 ;
37506 PyObject * obj1 = 0 ;
37507 char * kwnames[] = {
37508 (char *) "self",(char *) "sizer", NULL
37509 };
37510
37511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37513 if (!SWIG_IsOK(res1)) {
37514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37515 }
37516 arg1 = reinterpret_cast< wxWindow * >(argp1);
37517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37518 if (!SWIG_IsOK(res2)) {
37519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37520 }
37521 arg2 = reinterpret_cast< wxSizer * >(argp2);
37522 {
37523 PyThreadState* __tstate = wxPyBeginAllowThreads();
37524 (arg1)->SetContainingSizer(arg2);
37525 wxPyEndAllowThreads(__tstate);
37526 if (PyErr_Occurred()) SWIG_fail;
37527 }
37528 resultobj = SWIG_Py_Void();
37529 return resultobj;
37530 fail:
37531 return NULL;
37532 }
37533
37534
37535 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37536 PyObject *resultobj = 0;
37537 wxWindow *arg1 = (wxWindow *) 0 ;
37538 wxSizer *result = 0 ;
37539 void *argp1 = 0 ;
37540 int res1 = 0 ;
37541 PyObject *swig_obj[1] ;
37542
37543 if (!args) SWIG_fail;
37544 swig_obj[0] = args;
37545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37546 if (!SWIG_IsOK(res1)) {
37547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37548 }
37549 arg1 = reinterpret_cast< wxWindow * >(argp1);
37550 {
37551 PyThreadState* __tstate = wxPyBeginAllowThreads();
37552 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37553 wxPyEndAllowThreads(__tstate);
37554 if (PyErr_Occurred()) SWIG_fail;
37555 }
37556 {
37557 resultobj = wxPyMake_wxObject(result, (bool)0);
37558 }
37559 return resultobj;
37560 fail:
37561 return NULL;
37562 }
37563
37564
37565 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37566 PyObject *resultobj = 0;
37567 wxWindow *arg1 = (wxWindow *) 0 ;
37568 void *argp1 = 0 ;
37569 int res1 = 0 ;
37570 PyObject *swig_obj[1] ;
37571
37572 if (!args) SWIG_fail;
37573 swig_obj[0] = args;
37574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37575 if (!SWIG_IsOK(res1)) {
37576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37577 }
37578 arg1 = reinterpret_cast< wxWindow * >(argp1);
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 (arg1)->InheritAttributes();
37582 wxPyEndAllowThreads(__tstate);
37583 if (PyErr_Occurred()) SWIG_fail;
37584 }
37585 resultobj = SWIG_Py_Void();
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37593 PyObject *resultobj = 0;
37594 wxWindow *arg1 = (wxWindow *) 0 ;
37595 bool result;
37596 void *argp1 = 0 ;
37597 int res1 = 0 ;
37598 PyObject *swig_obj[1] ;
37599
37600 if (!args) SWIG_fail;
37601 swig_obj[0] = args;
37602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37603 if (!SWIG_IsOK(res1)) {
37604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37605 }
37606 arg1 = reinterpret_cast< wxWindow * >(argp1);
37607 {
37608 PyThreadState* __tstate = wxPyBeginAllowThreads();
37609 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37610 wxPyEndAllowThreads(__tstate);
37611 if (PyErr_Occurred()) SWIG_fail;
37612 }
37613 {
37614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37615 }
37616 return resultobj;
37617 fail:
37618 return NULL;
37619 }
37620
37621
37622 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37623 PyObject *obj;
37624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37625 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37626 return SWIG_Py_Void();
37627 }
37628
37629 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37630 return SWIG_Python_InitShadowInstance(args);
37631 }
37632
37633 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37634 PyObject *resultobj = 0;
37635 long arg1 ;
37636 wxWindow *arg2 = (wxWindow *) NULL ;
37637 wxWindow *result = 0 ;
37638 long val1 ;
37639 int ecode1 = 0 ;
37640 void *argp2 = 0 ;
37641 int res2 = 0 ;
37642 PyObject * obj0 = 0 ;
37643 PyObject * obj1 = 0 ;
37644 char * kwnames[] = {
37645 (char *) "id",(char *) "parent", NULL
37646 };
37647
37648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37649 ecode1 = SWIG_AsVal_long(obj0, &val1);
37650 if (!SWIG_IsOK(ecode1)) {
37651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37652 }
37653 arg1 = static_cast< long >(val1);
37654 if (obj1) {
37655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37656 if (!SWIG_IsOK(res2)) {
37657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37658 }
37659 arg2 = reinterpret_cast< wxWindow * >(argp2);
37660 }
37661 {
37662 if (!wxPyCheckForApp()) SWIG_fail;
37663 PyThreadState* __tstate = wxPyBeginAllowThreads();
37664 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37665 wxPyEndAllowThreads(__tstate);
37666 if (PyErr_Occurred()) SWIG_fail;
37667 }
37668 {
37669 resultobj = wxPyMake_wxObject(result, 0);
37670 }
37671 return resultobj;
37672 fail:
37673 return NULL;
37674 }
37675
37676
37677 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37678 PyObject *resultobj = 0;
37679 wxString *arg1 = 0 ;
37680 wxWindow *arg2 = (wxWindow *) NULL ;
37681 wxWindow *result = 0 ;
37682 bool temp1 = false ;
37683 void *argp2 = 0 ;
37684 int res2 = 0 ;
37685 PyObject * obj0 = 0 ;
37686 PyObject * obj1 = 0 ;
37687 char * kwnames[] = {
37688 (char *) "name",(char *) "parent", NULL
37689 };
37690
37691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37692 {
37693 arg1 = wxString_in_helper(obj0);
37694 if (arg1 == NULL) SWIG_fail;
37695 temp1 = true;
37696 }
37697 if (obj1) {
37698 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37699 if (!SWIG_IsOK(res2)) {
37700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37701 }
37702 arg2 = reinterpret_cast< wxWindow * >(argp2);
37703 }
37704 {
37705 if (!wxPyCheckForApp()) SWIG_fail;
37706 PyThreadState* __tstate = wxPyBeginAllowThreads();
37707 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37708 wxPyEndAllowThreads(__tstate);
37709 if (PyErr_Occurred()) SWIG_fail;
37710 }
37711 {
37712 resultobj = wxPyMake_wxObject(result, 0);
37713 }
37714 {
37715 if (temp1)
37716 delete arg1;
37717 }
37718 return resultobj;
37719 fail:
37720 {
37721 if (temp1)
37722 delete arg1;
37723 }
37724 return NULL;
37725 }
37726
37727
37728 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37729 PyObject *resultobj = 0;
37730 wxString *arg1 = 0 ;
37731 wxWindow *arg2 = (wxWindow *) NULL ;
37732 wxWindow *result = 0 ;
37733 bool temp1 = false ;
37734 void *argp2 = 0 ;
37735 int res2 = 0 ;
37736 PyObject * obj0 = 0 ;
37737 PyObject * obj1 = 0 ;
37738 char * kwnames[] = {
37739 (char *) "label",(char *) "parent", NULL
37740 };
37741
37742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37743 {
37744 arg1 = wxString_in_helper(obj0);
37745 if (arg1 == NULL) SWIG_fail;
37746 temp1 = true;
37747 }
37748 if (obj1) {
37749 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37750 if (!SWIG_IsOK(res2)) {
37751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37752 }
37753 arg2 = reinterpret_cast< wxWindow * >(argp2);
37754 }
37755 {
37756 if (!wxPyCheckForApp()) SWIG_fail;
37757 PyThreadState* __tstate = wxPyBeginAllowThreads();
37758 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37759 wxPyEndAllowThreads(__tstate);
37760 if (PyErr_Occurred()) SWIG_fail;
37761 }
37762 {
37763 resultobj = wxPyMake_wxObject(result, 0);
37764 }
37765 {
37766 if (temp1)
37767 delete arg1;
37768 }
37769 return resultobj;
37770 fail:
37771 {
37772 if (temp1)
37773 delete arg1;
37774 }
37775 return NULL;
37776 }
37777
37778
37779 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37780 PyObject *resultobj = 0;
37781 wxWindow *arg1 = (wxWindow *) 0 ;
37782 unsigned long arg2 ;
37783 wxWindow *result = 0 ;
37784 void *argp1 = 0 ;
37785 int res1 = 0 ;
37786 unsigned long val2 ;
37787 int ecode2 = 0 ;
37788 PyObject * obj0 = 0 ;
37789 PyObject * obj1 = 0 ;
37790 char * kwnames[] = {
37791 (char *) "parent",(char *) "_hWnd", NULL
37792 };
37793
37794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37796 if (!SWIG_IsOK(res1)) {
37797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37798 }
37799 arg1 = reinterpret_cast< wxWindow * >(argp1);
37800 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37801 if (!SWIG_IsOK(ecode2)) {
37802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37803 }
37804 arg2 = static_cast< unsigned long >(val2);
37805 {
37806 PyThreadState* __tstate = wxPyBeginAllowThreads();
37807 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37808 wxPyEndAllowThreads(__tstate);
37809 if (PyErr_Occurred()) SWIG_fail;
37810 }
37811 {
37812 resultobj = wxPyMake_wxObject(result, 0);
37813 }
37814 return resultobj;
37815 fail:
37816 return NULL;
37817 }
37818
37819
37820 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37821 PyObject *resultobj = 0;
37822 PyObject *result = 0 ;
37823
37824 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37825 {
37826 PyThreadState* __tstate = wxPyBeginAllowThreads();
37827 result = (PyObject *)GetTopLevelWindows();
37828 wxPyEndAllowThreads(__tstate);
37829 if (PyErr_Occurred()) SWIG_fail;
37830 }
37831 resultobj = result;
37832 return resultobj;
37833 fail:
37834 return NULL;
37835 }
37836
37837
37838 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37839 PyObject *resultobj = 0;
37840 wxValidator *result = 0 ;
37841
37842 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37843 {
37844 PyThreadState* __tstate = wxPyBeginAllowThreads();
37845 result = (wxValidator *)new wxValidator();
37846 wxPyEndAllowThreads(__tstate);
37847 if (PyErr_Occurred()) SWIG_fail;
37848 }
37849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37850 return resultobj;
37851 fail:
37852 return NULL;
37853 }
37854
37855
37856 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37857 PyObject *resultobj = 0;
37858 wxValidator *arg1 = (wxValidator *) 0 ;
37859 wxValidator *result = 0 ;
37860 void *argp1 = 0 ;
37861 int res1 = 0 ;
37862 PyObject *swig_obj[1] ;
37863
37864 if (!args) SWIG_fail;
37865 swig_obj[0] = args;
37866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37867 if (!SWIG_IsOK(res1)) {
37868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37869 }
37870 arg1 = reinterpret_cast< wxValidator * >(argp1);
37871 {
37872 PyThreadState* __tstate = wxPyBeginAllowThreads();
37873 result = (wxValidator *)(arg1)->Clone();
37874 wxPyEndAllowThreads(__tstate);
37875 if (PyErr_Occurred()) SWIG_fail;
37876 }
37877 {
37878 resultobj = wxPyMake_wxObject(result, 0);
37879 }
37880 return resultobj;
37881 fail:
37882 return NULL;
37883 }
37884
37885
37886 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37887 PyObject *resultobj = 0;
37888 wxValidator *arg1 = (wxValidator *) 0 ;
37889 wxWindow *arg2 = (wxWindow *) 0 ;
37890 bool result;
37891 void *argp1 = 0 ;
37892 int res1 = 0 ;
37893 void *argp2 = 0 ;
37894 int res2 = 0 ;
37895 PyObject * obj0 = 0 ;
37896 PyObject * obj1 = 0 ;
37897 char * kwnames[] = {
37898 (char *) "self",(char *) "parent", NULL
37899 };
37900
37901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37903 if (!SWIG_IsOK(res1)) {
37904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37905 }
37906 arg1 = reinterpret_cast< wxValidator * >(argp1);
37907 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37908 if (!SWIG_IsOK(res2)) {
37909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37910 }
37911 arg2 = reinterpret_cast< wxWindow * >(argp2);
37912 {
37913 PyThreadState* __tstate = wxPyBeginAllowThreads();
37914 result = (bool)(arg1)->Validate(arg2);
37915 wxPyEndAllowThreads(__tstate);
37916 if (PyErr_Occurred()) SWIG_fail;
37917 }
37918 {
37919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37920 }
37921 return resultobj;
37922 fail:
37923 return NULL;
37924 }
37925
37926
37927 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37928 PyObject *resultobj = 0;
37929 wxValidator *arg1 = (wxValidator *) 0 ;
37930 bool result;
37931 void *argp1 = 0 ;
37932 int res1 = 0 ;
37933 PyObject *swig_obj[1] ;
37934
37935 if (!args) SWIG_fail;
37936 swig_obj[0] = args;
37937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37938 if (!SWIG_IsOK(res1)) {
37939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37940 }
37941 arg1 = reinterpret_cast< wxValidator * >(argp1);
37942 {
37943 PyThreadState* __tstate = wxPyBeginAllowThreads();
37944 result = (bool)(arg1)->TransferToWindow();
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 {
37949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37950 }
37951 return resultobj;
37952 fail:
37953 return NULL;
37954 }
37955
37956
37957 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37958 PyObject *resultobj = 0;
37959 wxValidator *arg1 = (wxValidator *) 0 ;
37960 bool result;
37961 void *argp1 = 0 ;
37962 int res1 = 0 ;
37963 PyObject *swig_obj[1] ;
37964
37965 if (!args) SWIG_fail;
37966 swig_obj[0] = args;
37967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37968 if (!SWIG_IsOK(res1)) {
37969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37970 }
37971 arg1 = reinterpret_cast< wxValidator * >(argp1);
37972 {
37973 PyThreadState* __tstate = wxPyBeginAllowThreads();
37974 result = (bool)(arg1)->TransferFromWindow();
37975 wxPyEndAllowThreads(__tstate);
37976 if (PyErr_Occurred()) SWIG_fail;
37977 }
37978 {
37979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37980 }
37981 return resultobj;
37982 fail:
37983 return NULL;
37984 }
37985
37986
37987 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37988 PyObject *resultobj = 0;
37989 wxValidator *arg1 = (wxValidator *) 0 ;
37990 wxWindow *result = 0 ;
37991 void *argp1 = 0 ;
37992 int res1 = 0 ;
37993 PyObject *swig_obj[1] ;
37994
37995 if (!args) SWIG_fail;
37996 swig_obj[0] = args;
37997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37998 if (!SWIG_IsOK(res1)) {
37999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38000 }
38001 arg1 = reinterpret_cast< wxValidator * >(argp1);
38002 {
38003 PyThreadState* __tstate = wxPyBeginAllowThreads();
38004 result = (wxWindow *)(arg1)->GetWindow();
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 {
38009 resultobj = wxPyMake_wxObject(result, 0);
38010 }
38011 return resultobj;
38012 fail:
38013 return NULL;
38014 }
38015
38016
38017 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38018 PyObject *resultobj = 0;
38019 wxValidator *arg1 = (wxValidator *) 0 ;
38020 wxWindow *arg2 = (wxWindow *) 0 ;
38021 void *argp1 = 0 ;
38022 int res1 = 0 ;
38023 void *argp2 = 0 ;
38024 int res2 = 0 ;
38025 PyObject * obj0 = 0 ;
38026 PyObject * obj1 = 0 ;
38027 char * kwnames[] = {
38028 (char *) "self",(char *) "window", NULL
38029 };
38030
38031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38033 if (!SWIG_IsOK(res1)) {
38034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38035 }
38036 arg1 = reinterpret_cast< wxValidator * >(argp1);
38037 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38038 if (!SWIG_IsOK(res2)) {
38039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38040 }
38041 arg2 = reinterpret_cast< wxWindow * >(argp2);
38042 {
38043 PyThreadState* __tstate = wxPyBeginAllowThreads();
38044 (arg1)->SetWindow(arg2);
38045 wxPyEndAllowThreads(__tstate);
38046 if (PyErr_Occurred()) SWIG_fail;
38047 }
38048 resultobj = SWIG_Py_Void();
38049 return resultobj;
38050 fail:
38051 return NULL;
38052 }
38053
38054
38055 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38056 PyObject *resultobj = 0;
38057 bool result;
38058
38059 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38060 {
38061 PyThreadState* __tstate = wxPyBeginAllowThreads();
38062 result = (bool)wxValidator::IsSilent();
38063 wxPyEndAllowThreads(__tstate);
38064 if (PyErr_Occurred()) SWIG_fail;
38065 }
38066 {
38067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38068 }
38069 return resultobj;
38070 fail:
38071 return NULL;
38072 }
38073
38074
38075 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38076 PyObject *resultobj = 0;
38077 int arg1 = (int) true ;
38078 int val1 ;
38079 int ecode1 = 0 ;
38080 PyObject * obj0 = 0 ;
38081 char * kwnames[] = {
38082 (char *) "doIt", NULL
38083 };
38084
38085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38086 if (obj0) {
38087 ecode1 = SWIG_AsVal_int(obj0, &val1);
38088 if (!SWIG_IsOK(ecode1)) {
38089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38090 }
38091 arg1 = static_cast< int >(val1);
38092 }
38093 {
38094 PyThreadState* __tstate = wxPyBeginAllowThreads();
38095 wxValidator::SetBellOnError(arg1);
38096 wxPyEndAllowThreads(__tstate);
38097 if (PyErr_Occurred()) SWIG_fail;
38098 }
38099 resultobj = SWIG_Py_Void();
38100 return resultobj;
38101 fail:
38102 return NULL;
38103 }
38104
38105
38106 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38107 PyObject *obj;
38108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38109 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38110 return SWIG_Py_Void();
38111 }
38112
38113 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38114 return SWIG_Python_InitShadowInstance(args);
38115 }
38116
38117 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38118 PyObject *resultobj = 0;
38119 wxPyValidator *result = 0 ;
38120
38121 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38122 {
38123 PyThreadState* __tstate = wxPyBeginAllowThreads();
38124 result = (wxPyValidator *)new wxPyValidator();
38125 wxPyEndAllowThreads(__tstate);
38126 if (PyErr_Occurred()) SWIG_fail;
38127 }
38128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38129 return resultobj;
38130 fail:
38131 return NULL;
38132 }
38133
38134
38135 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38136 PyObject *resultobj = 0;
38137 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38138 PyObject *arg2 = (PyObject *) 0 ;
38139 PyObject *arg3 = (PyObject *) 0 ;
38140 int arg4 = (int) true ;
38141 void *argp1 = 0 ;
38142 int res1 = 0 ;
38143 int val4 ;
38144 int ecode4 = 0 ;
38145 PyObject * obj0 = 0 ;
38146 PyObject * obj1 = 0 ;
38147 PyObject * obj2 = 0 ;
38148 PyObject * obj3 = 0 ;
38149 char * kwnames[] = {
38150 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38151 };
38152
38153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38155 if (!SWIG_IsOK(res1)) {
38156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38157 }
38158 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38159 arg2 = obj1;
38160 arg3 = obj2;
38161 if (obj3) {
38162 ecode4 = SWIG_AsVal_int(obj3, &val4);
38163 if (!SWIG_IsOK(ecode4)) {
38164 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38165 }
38166 arg4 = static_cast< int >(val4);
38167 }
38168 {
38169 PyThreadState* __tstate = wxPyBeginAllowThreads();
38170 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38171 wxPyEndAllowThreads(__tstate);
38172 if (PyErr_Occurred()) SWIG_fail;
38173 }
38174 resultobj = SWIG_Py_Void();
38175 return resultobj;
38176 fail:
38177 return NULL;
38178 }
38179
38180
38181 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38182 PyObject *obj;
38183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38184 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38185 return SWIG_Py_Void();
38186 }
38187
38188 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38189 return SWIG_Python_InitShadowInstance(args);
38190 }
38191
38192 SWIGINTERN int DefaultValidator_set(PyObject *) {
38193 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38194 return 1;
38195 }
38196
38197
38198 SWIGINTERN PyObject *DefaultValidator_get(void) {
38199 PyObject *pyobj = 0;
38200
38201 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38202 return pyobj;
38203 }
38204
38205
38206 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38207 PyObject *resultobj = 0;
38208 wxString const &arg1_defvalue = wxPyEmptyString ;
38209 wxString *arg1 = (wxString *) &arg1_defvalue ;
38210 long arg2 = (long) 0 ;
38211 wxMenu *result = 0 ;
38212 bool temp1 = false ;
38213 long val2 ;
38214 int ecode2 = 0 ;
38215 PyObject * obj0 = 0 ;
38216 PyObject * obj1 = 0 ;
38217 char * kwnames[] = {
38218 (char *) "title",(char *) "style", NULL
38219 };
38220
38221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38222 if (obj0) {
38223 {
38224 arg1 = wxString_in_helper(obj0);
38225 if (arg1 == NULL) SWIG_fail;
38226 temp1 = true;
38227 }
38228 }
38229 if (obj1) {
38230 ecode2 = SWIG_AsVal_long(obj1, &val2);
38231 if (!SWIG_IsOK(ecode2)) {
38232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38233 }
38234 arg2 = static_cast< long >(val2);
38235 }
38236 {
38237 if (!wxPyCheckForApp()) SWIG_fail;
38238 PyThreadState* __tstate = wxPyBeginAllowThreads();
38239 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38240 wxPyEndAllowThreads(__tstate);
38241 if (PyErr_Occurred()) SWIG_fail;
38242 }
38243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38244 {
38245 if (temp1)
38246 delete arg1;
38247 }
38248 return resultobj;
38249 fail:
38250 {
38251 if (temp1)
38252 delete arg1;
38253 }
38254 return NULL;
38255 }
38256
38257
38258 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38259 PyObject *resultobj = 0;
38260 wxMenu *arg1 = (wxMenu *) 0 ;
38261 int arg2 ;
38262 wxString *arg3 = 0 ;
38263 wxString const &arg4_defvalue = wxPyEmptyString ;
38264 wxString *arg4 = (wxString *) &arg4_defvalue ;
38265 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38266 wxMenuItem *result = 0 ;
38267 void *argp1 = 0 ;
38268 int res1 = 0 ;
38269 int val2 ;
38270 int ecode2 = 0 ;
38271 bool temp3 = false ;
38272 bool temp4 = false ;
38273 int val5 ;
38274 int ecode5 = 0 ;
38275 PyObject * obj0 = 0 ;
38276 PyObject * obj1 = 0 ;
38277 PyObject * obj2 = 0 ;
38278 PyObject * obj3 = 0 ;
38279 PyObject * obj4 = 0 ;
38280 char * kwnames[] = {
38281 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38282 };
38283
38284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38286 if (!SWIG_IsOK(res1)) {
38287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38288 }
38289 arg1 = reinterpret_cast< wxMenu * >(argp1);
38290 ecode2 = SWIG_AsVal_int(obj1, &val2);
38291 if (!SWIG_IsOK(ecode2)) {
38292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38293 }
38294 arg2 = static_cast< int >(val2);
38295 {
38296 arg3 = wxString_in_helper(obj2);
38297 if (arg3 == NULL) SWIG_fail;
38298 temp3 = true;
38299 }
38300 if (obj3) {
38301 {
38302 arg4 = wxString_in_helper(obj3);
38303 if (arg4 == NULL) SWIG_fail;
38304 temp4 = true;
38305 }
38306 }
38307 if (obj4) {
38308 ecode5 = SWIG_AsVal_int(obj4, &val5);
38309 if (!SWIG_IsOK(ecode5)) {
38310 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38311 }
38312 arg5 = static_cast< wxItemKind >(val5);
38313 }
38314 {
38315 PyThreadState* __tstate = wxPyBeginAllowThreads();
38316 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38317 wxPyEndAllowThreads(__tstate);
38318 if (PyErr_Occurred()) SWIG_fail;
38319 }
38320 {
38321 resultobj = wxPyMake_wxObject(result, (bool)0);
38322 }
38323 {
38324 if (temp3)
38325 delete arg3;
38326 }
38327 {
38328 if (temp4)
38329 delete arg4;
38330 }
38331 return resultobj;
38332 fail:
38333 {
38334 if (temp3)
38335 delete arg3;
38336 }
38337 {
38338 if (temp4)
38339 delete arg4;
38340 }
38341 return NULL;
38342 }
38343
38344
38345 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38346 PyObject *resultobj = 0;
38347 wxMenu *arg1 = (wxMenu *) 0 ;
38348 wxMenuItem *result = 0 ;
38349 void *argp1 = 0 ;
38350 int res1 = 0 ;
38351 PyObject *swig_obj[1] ;
38352
38353 if (!args) SWIG_fail;
38354 swig_obj[0] = args;
38355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38356 if (!SWIG_IsOK(res1)) {
38357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38358 }
38359 arg1 = reinterpret_cast< wxMenu * >(argp1);
38360 {
38361 PyThreadState* __tstate = wxPyBeginAllowThreads();
38362 result = (wxMenuItem *)(arg1)->AppendSeparator();
38363 wxPyEndAllowThreads(__tstate);
38364 if (PyErr_Occurred()) SWIG_fail;
38365 }
38366 {
38367 resultobj = wxPyMake_wxObject(result, (bool)0);
38368 }
38369 return resultobj;
38370 fail:
38371 return NULL;
38372 }
38373
38374
38375 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38376 PyObject *resultobj = 0;
38377 wxMenu *arg1 = (wxMenu *) 0 ;
38378 int arg2 ;
38379 wxString *arg3 = 0 ;
38380 wxString const &arg4_defvalue = wxPyEmptyString ;
38381 wxString *arg4 = (wxString *) &arg4_defvalue ;
38382 wxMenuItem *result = 0 ;
38383 void *argp1 = 0 ;
38384 int res1 = 0 ;
38385 int val2 ;
38386 int ecode2 = 0 ;
38387 bool temp3 = false ;
38388 bool temp4 = false ;
38389 PyObject * obj0 = 0 ;
38390 PyObject * obj1 = 0 ;
38391 PyObject * obj2 = 0 ;
38392 PyObject * obj3 = 0 ;
38393 char * kwnames[] = {
38394 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38395 };
38396
38397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38399 if (!SWIG_IsOK(res1)) {
38400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38401 }
38402 arg1 = reinterpret_cast< wxMenu * >(argp1);
38403 ecode2 = SWIG_AsVal_int(obj1, &val2);
38404 if (!SWIG_IsOK(ecode2)) {
38405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38406 }
38407 arg2 = static_cast< int >(val2);
38408 {
38409 arg3 = wxString_in_helper(obj2);
38410 if (arg3 == NULL) SWIG_fail;
38411 temp3 = true;
38412 }
38413 if (obj3) {
38414 {
38415 arg4 = wxString_in_helper(obj3);
38416 if (arg4 == NULL) SWIG_fail;
38417 temp4 = true;
38418 }
38419 }
38420 {
38421 PyThreadState* __tstate = wxPyBeginAllowThreads();
38422 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38423 wxPyEndAllowThreads(__tstate);
38424 if (PyErr_Occurred()) SWIG_fail;
38425 }
38426 {
38427 resultobj = wxPyMake_wxObject(result, (bool)0);
38428 }
38429 {
38430 if (temp3)
38431 delete arg3;
38432 }
38433 {
38434 if (temp4)
38435 delete arg4;
38436 }
38437 return resultobj;
38438 fail:
38439 {
38440 if (temp3)
38441 delete arg3;
38442 }
38443 {
38444 if (temp4)
38445 delete arg4;
38446 }
38447 return NULL;
38448 }
38449
38450
38451 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38452 PyObject *resultobj = 0;
38453 wxMenu *arg1 = (wxMenu *) 0 ;
38454 int arg2 ;
38455 wxString *arg3 = 0 ;
38456 wxString const &arg4_defvalue = wxPyEmptyString ;
38457 wxString *arg4 = (wxString *) &arg4_defvalue ;
38458 wxMenuItem *result = 0 ;
38459 void *argp1 = 0 ;
38460 int res1 = 0 ;
38461 int val2 ;
38462 int ecode2 = 0 ;
38463 bool temp3 = false ;
38464 bool temp4 = false ;
38465 PyObject * obj0 = 0 ;
38466 PyObject * obj1 = 0 ;
38467 PyObject * obj2 = 0 ;
38468 PyObject * obj3 = 0 ;
38469 char * kwnames[] = {
38470 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38471 };
38472
38473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38475 if (!SWIG_IsOK(res1)) {
38476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38477 }
38478 arg1 = reinterpret_cast< wxMenu * >(argp1);
38479 ecode2 = SWIG_AsVal_int(obj1, &val2);
38480 if (!SWIG_IsOK(ecode2)) {
38481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38482 }
38483 arg2 = static_cast< int >(val2);
38484 {
38485 arg3 = wxString_in_helper(obj2);
38486 if (arg3 == NULL) SWIG_fail;
38487 temp3 = true;
38488 }
38489 if (obj3) {
38490 {
38491 arg4 = wxString_in_helper(obj3);
38492 if (arg4 == NULL) SWIG_fail;
38493 temp4 = true;
38494 }
38495 }
38496 {
38497 PyThreadState* __tstate = wxPyBeginAllowThreads();
38498 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38499 wxPyEndAllowThreads(__tstate);
38500 if (PyErr_Occurred()) SWIG_fail;
38501 }
38502 {
38503 resultobj = wxPyMake_wxObject(result, (bool)0);
38504 }
38505 {
38506 if (temp3)
38507 delete arg3;
38508 }
38509 {
38510 if (temp4)
38511 delete arg4;
38512 }
38513 return resultobj;
38514 fail:
38515 {
38516 if (temp3)
38517 delete arg3;
38518 }
38519 {
38520 if (temp4)
38521 delete arg4;
38522 }
38523 return NULL;
38524 }
38525
38526
38527 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38528 PyObject *resultobj = 0;
38529 wxMenu *arg1 = (wxMenu *) 0 ;
38530 int arg2 ;
38531 wxString *arg3 = 0 ;
38532 wxMenu *arg4 = (wxMenu *) 0 ;
38533 wxString const &arg5_defvalue = wxPyEmptyString ;
38534 wxString *arg5 = (wxString *) &arg5_defvalue ;
38535 wxMenuItem *result = 0 ;
38536 void *argp1 = 0 ;
38537 int res1 = 0 ;
38538 int val2 ;
38539 int ecode2 = 0 ;
38540 bool temp3 = false ;
38541 void *argp4 = 0 ;
38542 int res4 = 0 ;
38543 bool temp5 = false ;
38544 PyObject * obj0 = 0 ;
38545 PyObject * obj1 = 0 ;
38546 PyObject * obj2 = 0 ;
38547 PyObject * obj3 = 0 ;
38548 PyObject * obj4 = 0 ;
38549 char * kwnames[] = {
38550 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38551 };
38552
38553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38555 if (!SWIG_IsOK(res1)) {
38556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38557 }
38558 arg1 = reinterpret_cast< wxMenu * >(argp1);
38559 ecode2 = SWIG_AsVal_int(obj1, &val2);
38560 if (!SWIG_IsOK(ecode2)) {
38561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38562 }
38563 arg2 = static_cast< int >(val2);
38564 {
38565 arg3 = wxString_in_helper(obj2);
38566 if (arg3 == NULL) SWIG_fail;
38567 temp3 = true;
38568 }
38569 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38570 if (!SWIG_IsOK(res4)) {
38571 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38572 }
38573 arg4 = reinterpret_cast< wxMenu * >(argp4);
38574 if (obj4) {
38575 {
38576 arg5 = wxString_in_helper(obj4);
38577 if (arg5 == NULL) SWIG_fail;
38578 temp5 = true;
38579 }
38580 }
38581 {
38582 PyThreadState* __tstate = wxPyBeginAllowThreads();
38583 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38584 wxPyEndAllowThreads(__tstate);
38585 if (PyErr_Occurred()) SWIG_fail;
38586 }
38587 {
38588 resultobj = wxPyMake_wxObject(result, (bool)0);
38589 }
38590 {
38591 if (temp3)
38592 delete arg3;
38593 }
38594 {
38595 if (temp5)
38596 delete arg5;
38597 }
38598 return resultobj;
38599 fail:
38600 {
38601 if (temp3)
38602 delete arg3;
38603 }
38604 {
38605 if (temp5)
38606 delete arg5;
38607 }
38608 return NULL;
38609 }
38610
38611
38612 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38613 PyObject *resultobj = 0;
38614 wxMenu *arg1 = (wxMenu *) 0 ;
38615 wxMenu *arg2 = (wxMenu *) 0 ;
38616 wxString *arg3 = 0 ;
38617 wxString const &arg4_defvalue = wxPyEmptyString ;
38618 wxString *arg4 = (wxString *) &arg4_defvalue ;
38619 wxMenuItem *result = 0 ;
38620 void *argp1 = 0 ;
38621 int res1 = 0 ;
38622 void *argp2 = 0 ;
38623 int res2 = 0 ;
38624 bool temp3 = false ;
38625 bool temp4 = false ;
38626 PyObject * obj0 = 0 ;
38627 PyObject * obj1 = 0 ;
38628 PyObject * obj2 = 0 ;
38629 PyObject * obj3 = 0 ;
38630 char * kwnames[] = {
38631 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38632 };
38633
38634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38636 if (!SWIG_IsOK(res1)) {
38637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38638 }
38639 arg1 = reinterpret_cast< wxMenu * >(argp1);
38640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38641 if (!SWIG_IsOK(res2)) {
38642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38643 }
38644 arg2 = reinterpret_cast< wxMenu * >(argp2);
38645 {
38646 arg3 = wxString_in_helper(obj2);
38647 if (arg3 == NULL) SWIG_fail;
38648 temp3 = true;
38649 }
38650 if (obj3) {
38651 {
38652 arg4 = wxString_in_helper(obj3);
38653 if (arg4 == NULL) SWIG_fail;
38654 temp4 = true;
38655 }
38656 }
38657 {
38658 PyThreadState* __tstate = wxPyBeginAllowThreads();
38659 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38660 wxPyEndAllowThreads(__tstate);
38661 if (PyErr_Occurred()) SWIG_fail;
38662 }
38663 {
38664 resultobj = wxPyMake_wxObject(result, (bool)0);
38665 }
38666 {
38667 if (temp3)
38668 delete arg3;
38669 }
38670 {
38671 if (temp4)
38672 delete arg4;
38673 }
38674 return resultobj;
38675 fail:
38676 {
38677 if (temp3)
38678 delete arg3;
38679 }
38680 {
38681 if (temp4)
38682 delete arg4;
38683 }
38684 return NULL;
38685 }
38686
38687
38688 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38689 PyObject *resultobj = 0;
38690 wxMenu *arg1 = (wxMenu *) 0 ;
38691 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38692 wxMenuItem *result = 0 ;
38693 void *argp1 = 0 ;
38694 int res1 = 0 ;
38695 int res2 = 0 ;
38696 PyObject * obj0 = 0 ;
38697 PyObject * obj1 = 0 ;
38698 char * kwnames[] = {
38699 (char *) "self",(char *) "item", NULL
38700 };
38701
38702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38704 if (!SWIG_IsOK(res1)) {
38705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38706 }
38707 arg1 = reinterpret_cast< wxMenu * >(argp1);
38708 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38709 if (!SWIG_IsOK(res2)) {
38710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38711 }
38712 {
38713 PyThreadState* __tstate = wxPyBeginAllowThreads();
38714 result = (wxMenuItem *)(arg1)->Append(arg2);
38715 wxPyEndAllowThreads(__tstate);
38716 if (PyErr_Occurred()) SWIG_fail;
38717 }
38718 {
38719 resultobj = wxPyMake_wxObject(result, (bool)0);
38720 }
38721 return resultobj;
38722 fail:
38723 return NULL;
38724 }
38725
38726
38727 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38728 PyObject *resultobj = 0;
38729 wxMenu *arg1 = (wxMenu *) 0 ;
38730 size_t arg2 ;
38731 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38732 wxMenuItem *result = 0 ;
38733 void *argp1 = 0 ;
38734 int res1 = 0 ;
38735 size_t val2 ;
38736 int ecode2 = 0 ;
38737 int res3 = 0 ;
38738 PyObject * obj0 = 0 ;
38739 PyObject * obj1 = 0 ;
38740 PyObject * obj2 = 0 ;
38741 char * kwnames[] = {
38742 (char *) "self",(char *) "pos",(char *) "item", NULL
38743 };
38744
38745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38747 if (!SWIG_IsOK(res1)) {
38748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38749 }
38750 arg1 = reinterpret_cast< wxMenu * >(argp1);
38751 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38752 if (!SWIG_IsOK(ecode2)) {
38753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38754 }
38755 arg2 = static_cast< size_t >(val2);
38756 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38757 if (!SWIG_IsOK(res3)) {
38758 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38759 }
38760 {
38761 PyThreadState* __tstate = wxPyBeginAllowThreads();
38762 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38763 wxPyEndAllowThreads(__tstate);
38764 if (PyErr_Occurred()) SWIG_fail;
38765 }
38766 {
38767 resultobj = wxPyMake_wxObject(result, (bool)0);
38768 }
38769 return resultobj;
38770 fail:
38771 return NULL;
38772 }
38773
38774
38775 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38776 PyObject *resultobj = 0;
38777 wxMenu *arg1 = (wxMenu *) 0 ;
38778 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38779 wxMenuItem *result = 0 ;
38780 void *argp1 = 0 ;
38781 int res1 = 0 ;
38782 int res2 = 0 ;
38783 PyObject * obj0 = 0 ;
38784 PyObject * obj1 = 0 ;
38785 char * kwnames[] = {
38786 (char *) "self",(char *) "item", NULL
38787 };
38788
38789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38791 if (!SWIG_IsOK(res1)) {
38792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38793 }
38794 arg1 = reinterpret_cast< wxMenu * >(argp1);
38795 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38796 if (!SWIG_IsOK(res2)) {
38797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38798 }
38799 {
38800 PyThreadState* __tstate = wxPyBeginAllowThreads();
38801 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38802 wxPyEndAllowThreads(__tstate);
38803 if (PyErr_Occurred()) SWIG_fail;
38804 }
38805 {
38806 resultobj = wxPyMake_wxObject(result, (bool)0);
38807 }
38808 return resultobj;
38809 fail:
38810 return NULL;
38811 }
38812
38813
38814 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38815 PyObject *resultobj = 0;
38816 wxMenu *arg1 = (wxMenu *) 0 ;
38817 void *argp1 = 0 ;
38818 int res1 = 0 ;
38819 PyObject *swig_obj[1] ;
38820
38821 if (!args) SWIG_fail;
38822 swig_obj[0] = args;
38823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38824 if (!SWIG_IsOK(res1)) {
38825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38826 }
38827 arg1 = reinterpret_cast< wxMenu * >(argp1);
38828 {
38829 PyThreadState* __tstate = wxPyBeginAllowThreads();
38830 (arg1)->Break();
38831 wxPyEndAllowThreads(__tstate);
38832 if (PyErr_Occurred()) SWIG_fail;
38833 }
38834 resultobj = SWIG_Py_Void();
38835 return resultobj;
38836 fail:
38837 return NULL;
38838 }
38839
38840
38841 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38842 PyObject *resultobj = 0;
38843 wxMenu *arg1 = (wxMenu *) 0 ;
38844 size_t arg2 ;
38845 int arg3 ;
38846 wxString *arg4 = 0 ;
38847 wxString const &arg5_defvalue = wxPyEmptyString ;
38848 wxString *arg5 = (wxString *) &arg5_defvalue ;
38849 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38850 wxMenuItem *result = 0 ;
38851 void *argp1 = 0 ;
38852 int res1 = 0 ;
38853 size_t val2 ;
38854 int ecode2 = 0 ;
38855 int val3 ;
38856 int ecode3 = 0 ;
38857 bool temp4 = false ;
38858 bool temp5 = false ;
38859 int val6 ;
38860 int ecode6 = 0 ;
38861 PyObject * obj0 = 0 ;
38862 PyObject * obj1 = 0 ;
38863 PyObject * obj2 = 0 ;
38864 PyObject * obj3 = 0 ;
38865 PyObject * obj4 = 0 ;
38866 PyObject * obj5 = 0 ;
38867 char * kwnames[] = {
38868 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38869 };
38870
38871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38873 if (!SWIG_IsOK(res1)) {
38874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38875 }
38876 arg1 = reinterpret_cast< wxMenu * >(argp1);
38877 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38878 if (!SWIG_IsOK(ecode2)) {
38879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38880 }
38881 arg2 = static_cast< size_t >(val2);
38882 ecode3 = SWIG_AsVal_int(obj2, &val3);
38883 if (!SWIG_IsOK(ecode3)) {
38884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38885 }
38886 arg3 = static_cast< int >(val3);
38887 {
38888 arg4 = wxString_in_helper(obj3);
38889 if (arg4 == NULL) SWIG_fail;
38890 temp4 = true;
38891 }
38892 if (obj4) {
38893 {
38894 arg5 = wxString_in_helper(obj4);
38895 if (arg5 == NULL) SWIG_fail;
38896 temp5 = true;
38897 }
38898 }
38899 if (obj5) {
38900 ecode6 = SWIG_AsVal_int(obj5, &val6);
38901 if (!SWIG_IsOK(ecode6)) {
38902 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38903 }
38904 arg6 = static_cast< wxItemKind >(val6);
38905 }
38906 {
38907 PyThreadState* __tstate = wxPyBeginAllowThreads();
38908 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38909 wxPyEndAllowThreads(__tstate);
38910 if (PyErr_Occurred()) SWIG_fail;
38911 }
38912 {
38913 resultobj = wxPyMake_wxObject(result, (bool)0);
38914 }
38915 {
38916 if (temp4)
38917 delete arg4;
38918 }
38919 {
38920 if (temp5)
38921 delete arg5;
38922 }
38923 return resultobj;
38924 fail:
38925 {
38926 if (temp4)
38927 delete arg4;
38928 }
38929 {
38930 if (temp5)
38931 delete arg5;
38932 }
38933 return NULL;
38934 }
38935
38936
38937 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38938 PyObject *resultobj = 0;
38939 wxMenu *arg1 = (wxMenu *) 0 ;
38940 size_t arg2 ;
38941 wxMenuItem *result = 0 ;
38942 void *argp1 = 0 ;
38943 int res1 = 0 ;
38944 size_t val2 ;
38945 int ecode2 = 0 ;
38946 PyObject * obj0 = 0 ;
38947 PyObject * obj1 = 0 ;
38948 char * kwnames[] = {
38949 (char *) "self",(char *) "pos", NULL
38950 };
38951
38952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38954 if (!SWIG_IsOK(res1)) {
38955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38956 }
38957 arg1 = reinterpret_cast< wxMenu * >(argp1);
38958 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38959 if (!SWIG_IsOK(ecode2)) {
38960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38961 }
38962 arg2 = static_cast< size_t >(val2);
38963 {
38964 PyThreadState* __tstate = wxPyBeginAllowThreads();
38965 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38966 wxPyEndAllowThreads(__tstate);
38967 if (PyErr_Occurred()) SWIG_fail;
38968 }
38969 {
38970 resultobj = wxPyMake_wxObject(result, (bool)0);
38971 }
38972 return resultobj;
38973 fail:
38974 return NULL;
38975 }
38976
38977
38978 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38979 PyObject *resultobj = 0;
38980 wxMenu *arg1 = (wxMenu *) 0 ;
38981 size_t arg2 ;
38982 int arg3 ;
38983 wxString *arg4 = 0 ;
38984 wxString const &arg5_defvalue = wxPyEmptyString ;
38985 wxString *arg5 = (wxString *) &arg5_defvalue ;
38986 wxMenuItem *result = 0 ;
38987 void *argp1 = 0 ;
38988 int res1 = 0 ;
38989 size_t val2 ;
38990 int ecode2 = 0 ;
38991 int val3 ;
38992 int ecode3 = 0 ;
38993 bool temp4 = false ;
38994 bool temp5 = false ;
38995 PyObject * obj0 = 0 ;
38996 PyObject * obj1 = 0 ;
38997 PyObject * obj2 = 0 ;
38998 PyObject * obj3 = 0 ;
38999 PyObject * obj4 = 0 ;
39000 char * kwnames[] = {
39001 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39002 };
39003
39004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39006 if (!SWIG_IsOK(res1)) {
39007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39008 }
39009 arg1 = reinterpret_cast< wxMenu * >(argp1);
39010 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39011 if (!SWIG_IsOK(ecode2)) {
39012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39013 }
39014 arg2 = static_cast< size_t >(val2);
39015 ecode3 = SWIG_AsVal_int(obj2, &val3);
39016 if (!SWIG_IsOK(ecode3)) {
39017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39018 }
39019 arg3 = static_cast< int >(val3);
39020 {
39021 arg4 = wxString_in_helper(obj3);
39022 if (arg4 == NULL) SWIG_fail;
39023 temp4 = true;
39024 }
39025 if (obj4) {
39026 {
39027 arg5 = wxString_in_helper(obj4);
39028 if (arg5 == NULL) SWIG_fail;
39029 temp5 = true;
39030 }
39031 }
39032 {
39033 PyThreadState* __tstate = wxPyBeginAllowThreads();
39034 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39035 wxPyEndAllowThreads(__tstate);
39036 if (PyErr_Occurred()) SWIG_fail;
39037 }
39038 {
39039 resultobj = wxPyMake_wxObject(result, (bool)0);
39040 }
39041 {
39042 if (temp4)
39043 delete arg4;
39044 }
39045 {
39046 if (temp5)
39047 delete arg5;
39048 }
39049 return resultobj;
39050 fail:
39051 {
39052 if (temp4)
39053 delete arg4;
39054 }
39055 {
39056 if (temp5)
39057 delete arg5;
39058 }
39059 return NULL;
39060 }
39061
39062
39063 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39064 PyObject *resultobj = 0;
39065 wxMenu *arg1 = (wxMenu *) 0 ;
39066 size_t arg2 ;
39067 int arg3 ;
39068 wxString *arg4 = 0 ;
39069 wxString const &arg5_defvalue = wxPyEmptyString ;
39070 wxString *arg5 = (wxString *) &arg5_defvalue ;
39071 wxMenuItem *result = 0 ;
39072 void *argp1 = 0 ;
39073 int res1 = 0 ;
39074 size_t val2 ;
39075 int ecode2 = 0 ;
39076 int val3 ;
39077 int ecode3 = 0 ;
39078 bool temp4 = false ;
39079 bool temp5 = false ;
39080 PyObject * obj0 = 0 ;
39081 PyObject * obj1 = 0 ;
39082 PyObject * obj2 = 0 ;
39083 PyObject * obj3 = 0 ;
39084 PyObject * obj4 = 0 ;
39085 char * kwnames[] = {
39086 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39087 };
39088
39089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39091 if (!SWIG_IsOK(res1)) {
39092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39093 }
39094 arg1 = reinterpret_cast< wxMenu * >(argp1);
39095 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39096 if (!SWIG_IsOK(ecode2)) {
39097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39098 }
39099 arg2 = static_cast< size_t >(val2);
39100 ecode3 = SWIG_AsVal_int(obj2, &val3);
39101 if (!SWIG_IsOK(ecode3)) {
39102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39103 }
39104 arg3 = static_cast< int >(val3);
39105 {
39106 arg4 = wxString_in_helper(obj3);
39107 if (arg4 == NULL) SWIG_fail;
39108 temp4 = true;
39109 }
39110 if (obj4) {
39111 {
39112 arg5 = wxString_in_helper(obj4);
39113 if (arg5 == NULL) SWIG_fail;
39114 temp5 = true;
39115 }
39116 }
39117 {
39118 PyThreadState* __tstate = wxPyBeginAllowThreads();
39119 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39120 wxPyEndAllowThreads(__tstate);
39121 if (PyErr_Occurred()) SWIG_fail;
39122 }
39123 {
39124 resultobj = wxPyMake_wxObject(result, (bool)0);
39125 }
39126 {
39127 if (temp4)
39128 delete arg4;
39129 }
39130 {
39131 if (temp5)
39132 delete arg5;
39133 }
39134 return resultobj;
39135 fail:
39136 {
39137 if (temp4)
39138 delete arg4;
39139 }
39140 {
39141 if (temp5)
39142 delete arg5;
39143 }
39144 return NULL;
39145 }
39146
39147
39148 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39149 PyObject *resultobj = 0;
39150 wxMenu *arg1 = (wxMenu *) 0 ;
39151 size_t arg2 ;
39152 int arg3 ;
39153 wxString *arg4 = 0 ;
39154 wxMenu *arg5 = (wxMenu *) 0 ;
39155 wxString const &arg6_defvalue = wxPyEmptyString ;
39156 wxString *arg6 = (wxString *) &arg6_defvalue ;
39157 wxMenuItem *result = 0 ;
39158 void *argp1 = 0 ;
39159 int res1 = 0 ;
39160 size_t val2 ;
39161 int ecode2 = 0 ;
39162 int val3 ;
39163 int ecode3 = 0 ;
39164 bool temp4 = false ;
39165 void *argp5 = 0 ;
39166 int res5 = 0 ;
39167 bool temp6 = false ;
39168 PyObject * obj0 = 0 ;
39169 PyObject * obj1 = 0 ;
39170 PyObject * obj2 = 0 ;
39171 PyObject * obj3 = 0 ;
39172 PyObject * obj4 = 0 ;
39173 PyObject * obj5 = 0 ;
39174 char * kwnames[] = {
39175 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39176 };
39177
39178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39180 if (!SWIG_IsOK(res1)) {
39181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39182 }
39183 arg1 = reinterpret_cast< wxMenu * >(argp1);
39184 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39185 if (!SWIG_IsOK(ecode2)) {
39186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39187 }
39188 arg2 = static_cast< size_t >(val2);
39189 ecode3 = SWIG_AsVal_int(obj2, &val3);
39190 if (!SWIG_IsOK(ecode3)) {
39191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39192 }
39193 arg3 = static_cast< int >(val3);
39194 {
39195 arg4 = wxString_in_helper(obj3);
39196 if (arg4 == NULL) SWIG_fail;
39197 temp4 = true;
39198 }
39199 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39200 if (!SWIG_IsOK(res5)) {
39201 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39202 }
39203 arg5 = reinterpret_cast< wxMenu * >(argp5);
39204 if (obj5) {
39205 {
39206 arg6 = wxString_in_helper(obj5);
39207 if (arg6 == NULL) SWIG_fail;
39208 temp6 = true;
39209 }
39210 }
39211 {
39212 PyThreadState* __tstate = wxPyBeginAllowThreads();
39213 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39214 wxPyEndAllowThreads(__tstate);
39215 if (PyErr_Occurred()) SWIG_fail;
39216 }
39217 {
39218 resultobj = wxPyMake_wxObject(result, (bool)0);
39219 }
39220 {
39221 if (temp4)
39222 delete arg4;
39223 }
39224 {
39225 if (temp6)
39226 delete arg6;
39227 }
39228 return resultobj;
39229 fail:
39230 {
39231 if (temp4)
39232 delete arg4;
39233 }
39234 {
39235 if (temp6)
39236 delete arg6;
39237 }
39238 return NULL;
39239 }
39240
39241
39242 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39243 PyObject *resultobj = 0;
39244 wxMenu *arg1 = (wxMenu *) 0 ;
39245 int arg2 ;
39246 wxString *arg3 = 0 ;
39247 wxString const &arg4_defvalue = wxPyEmptyString ;
39248 wxString *arg4 = (wxString *) &arg4_defvalue ;
39249 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39250 wxMenuItem *result = 0 ;
39251 void *argp1 = 0 ;
39252 int res1 = 0 ;
39253 int val2 ;
39254 int ecode2 = 0 ;
39255 bool temp3 = false ;
39256 bool temp4 = false ;
39257 int val5 ;
39258 int ecode5 = 0 ;
39259 PyObject * obj0 = 0 ;
39260 PyObject * obj1 = 0 ;
39261 PyObject * obj2 = 0 ;
39262 PyObject * obj3 = 0 ;
39263 PyObject * obj4 = 0 ;
39264 char * kwnames[] = {
39265 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39266 };
39267
39268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39270 if (!SWIG_IsOK(res1)) {
39271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39272 }
39273 arg1 = reinterpret_cast< wxMenu * >(argp1);
39274 ecode2 = SWIG_AsVal_int(obj1, &val2);
39275 if (!SWIG_IsOK(ecode2)) {
39276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39277 }
39278 arg2 = static_cast< int >(val2);
39279 {
39280 arg3 = wxString_in_helper(obj2);
39281 if (arg3 == NULL) SWIG_fail;
39282 temp3 = true;
39283 }
39284 if (obj3) {
39285 {
39286 arg4 = wxString_in_helper(obj3);
39287 if (arg4 == NULL) SWIG_fail;
39288 temp4 = true;
39289 }
39290 }
39291 if (obj4) {
39292 ecode5 = SWIG_AsVal_int(obj4, &val5);
39293 if (!SWIG_IsOK(ecode5)) {
39294 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39295 }
39296 arg5 = static_cast< wxItemKind >(val5);
39297 }
39298 {
39299 PyThreadState* __tstate = wxPyBeginAllowThreads();
39300 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39301 wxPyEndAllowThreads(__tstate);
39302 if (PyErr_Occurred()) SWIG_fail;
39303 }
39304 {
39305 resultobj = wxPyMake_wxObject(result, (bool)0);
39306 }
39307 {
39308 if (temp3)
39309 delete arg3;
39310 }
39311 {
39312 if (temp4)
39313 delete arg4;
39314 }
39315 return resultobj;
39316 fail:
39317 {
39318 if (temp3)
39319 delete arg3;
39320 }
39321 {
39322 if (temp4)
39323 delete arg4;
39324 }
39325 return NULL;
39326 }
39327
39328
39329 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39330 PyObject *resultobj = 0;
39331 wxMenu *arg1 = (wxMenu *) 0 ;
39332 wxMenuItem *result = 0 ;
39333 void *argp1 = 0 ;
39334 int res1 = 0 ;
39335 PyObject *swig_obj[1] ;
39336
39337 if (!args) SWIG_fail;
39338 swig_obj[0] = args;
39339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39340 if (!SWIG_IsOK(res1)) {
39341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39342 }
39343 arg1 = reinterpret_cast< wxMenu * >(argp1);
39344 {
39345 PyThreadState* __tstate = wxPyBeginAllowThreads();
39346 result = (wxMenuItem *)(arg1)->PrependSeparator();
39347 wxPyEndAllowThreads(__tstate);
39348 if (PyErr_Occurred()) SWIG_fail;
39349 }
39350 {
39351 resultobj = wxPyMake_wxObject(result, (bool)0);
39352 }
39353 return resultobj;
39354 fail:
39355 return NULL;
39356 }
39357
39358
39359 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39360 PyObject *resultobj = 0;
39361 wxMenu *arg1 = (wxMenu *) 0 ;
39362 int arg2 ;
39363 wxString *arg3 = 0 ;
39364 wxString const &arg4_defvalue = wxPyEmptyString ;
39365 wxString *arg4 = (wxString *) &arg4_defvalue ;
39366 wxMenuItem *result = 0 ;
39367 void *argp1 = 0 ;
39368 int res1 = 0 ;
39369 int val2 ;
39370 int ecode2 = 0 ;
39371 bool temp3 = false ;
39372 bool temp4 = false ;
39373 PyObject * obj0 = 0 ;
39374 PyObject * obj1 = 0 ;
39375 PyObject * obj2 = 0 ;
39376 PyObject * obj3 = 0 ;
39377 char * kwnames[] = {
39378 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39379 };
39380
39381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39383 if (!SWIG_IsOK(res1)) {
39384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39385 }
39386 arg1 = reinterpret_cast< wxMenu * >(argp1);
39387 ecode2 = SWIG_AsVal_int(obj1, &val2);
39388 if (!SWIG_IsOK(ecode2)) {
39389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39390 }
39391 arg2 = static_cast< int >(val2);
39392 {
39393 arg3 = wxString_in_helper(obj2);
39394 if (arg3 == NULL) SWIG_fail;
39395 temp3 = true;
39396 }
39397 if (obj3) {
39398 {
39399 arg4 = wxString_in_helper(obj3);
39400 if (arg4 == NULL) SWIG_fail;
39401 temp4 = true;
39402 }
39403 }
39404 {
39405 PyThreadState* __tstate = wxPyBeginAllowThreads();
39406 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39407 wxPyEndAllowThreads(__tstate);
39408 if (PyErr_Occurred()) SWIG_fail;
39409 }
39410 {
39411 resultobj = wxPyMake_wxObject(result, (bool)0);
39412 }
39413 {
39414 if (temp3)
39415 delete arg3;
39416 }
39417 {
39418 if (temp4)
39419 delete arg4;
39420 }
39421 return resultobj;
39422 fail:
39423 {
39424 if (temp3)
39425 delete arg3;
39426 }
39427 {
39428 if (temp4)
39429 delete arg4;
39430 }
39431 return NULL;
39432 }
39433
39434
39435 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39436 PyObject *resultobj = 0;
39437 wxMenu *arg1 = (wxMenu *) 0 ;
39438 int arg2 ;
39439 wxString *arg3 = 0 ;
39440 wxString const &arg4_defvalue = wxPyEmptyString ;
39441 wxString *arg4 = (wxString *) &arg4_defvalue ;
39442 wxMenuItem *result = 0 ;
39443 void *argp1 = 0 ;
39444 int res1 = 0 ;
39445 int val2 ;
39446 int ecode2 = 0 ;
39447 bool temp3 = false ;
39448 bool temp4 = false ;
39449 PyObject * obj0 = 0 ;
39450 PyObject * obj1 = 0 ;
39451 PyObject * obj2 = 0 ;
39452 PyObject * obj3 = 0 ;
39453 char * kwnames[] = {
39454 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39455 };
39456
39457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39459 if (!SWIG_IsOK(res1)) {
39460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39461 }
39462 arg1 = reinterpret_cast< wxMenu * >(argp1);
39463 ecode2 = SWIG_AsVal_int(obj1, &val2);
39464 if (!SWIG_IsOK(ecode2)) {
39465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39466 }
39467 arg2 = static_cast< int >(val2);
39468 {
39469 arg3 = wxString_in_helper(obj2);
39470 if (arg3 == NULL) SWIG_fail;
39471 temp3 = true;
39472 }
39473 if (obj3) {
39474 {
39475 arg4 = wxString_in_helper(obj3);
39476 if (arg4 == NULL) SWIG_fail;
39477 temp4 = true;
39478 }
39479 }
39480 {
39481 PyThreadState* __tstate = wxPyBeginAllowThreads();
39482 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39483 wxPyEndAllowThreads(__tstate);
39484 if (PyErr_Occurred()) SWIG_fail;
39485 }
39486 {
39487 resultobj = wxPyMake_wxObject(result, (bool)0);
39488 }
39489 {
39490 if (temp3)
39491 delete arg3;
39492 }
39493 {
39494 if (temp4)
39495 delete arg4;
39496 }
39497 return resultobj;
39498 fail:
39499 {
39500 if (temp3)
39501 delete arg3;
39502 }
39503 {
39504 if (temp4)
39505 delete arg4;
39506 }
39507 return NULL;
39508 }
39509
39510
39511 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39512 PyObject *resultobj = 0;
39513 wxMenu *arg1 = (wxMenu *) 0 ;
39514 int arg2 ;
39515 wxString *arg3 = 0 ;
39516 wxMenu *arg4 = (wxMenu *) 0 ;
39517 wxString const &arg5_defvalue = wxPyEmptyString ;
39518 wxString *arg5 = (wxString *) &arg5_defvalue ;
39519 wxMenuItem *result = 0 ;
39520 void *argp1 = 0 ;
39521 int res1 = 0 ;
39522 int val2 ;
39523 int ecode2 = 0 ;
39524 bool temp3 = false ;
39525 void *argp4 = 0 ;
39526 int res4 = 0 ;
39527 bool temp5 = false ;
39528 PyObject * obj0 = 0 ;
39529 PyObject * obj1 = 0 ;
39530 PyObject * obj2 = 0 ;
39531 PyObject * obj3 = 0 ;
39532 PyObject * obj4 = 0 ;
39533 char * kwnames[] = {
39534 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39535 };
39536
39537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39539 if (!SWIG_IsOK(res1)) {
39540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39541 }
39542 arg1 = reinterpret_cast< wxMenu * >(argp1);
39543 ecode2 = SWIG_AsVal_int(obj1, &val2);
39544 if (!SWIG_IsOK(ecode2)) {
39545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39546 }
39547 arg2 = static_cast< int >(val2);
39548 {
39549 arg3 = wxString_in_helper(obj2);
39550 if (arg3 == NULL) SWIG_fail;
39551 temp3 = true;
39552 }
39553 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39554 if (!SWIG_IsOK(res4)) {
39555 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39556 }
39557 arg4 = reinterpret_cast< wxMenu * >(argp4);
39558 if (obj4) {
39559 {
39560 arg5 = wxString_in_helper(obj4);
39561 if (arg5 == NULL) SWIG_fail;
39562 temp5 = true;
39563 }
39564 }
39565 {
39566 PyThreadState* __tstate = wxPyBeginAllowThreads();
39567 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39568 wxPyEndAllowThreads(__tstate);
39569 if (PyErr_Occurred()) SWIG_fail;
39570 }
39571 {
39572 resultobj = wxPyMake_wxObject(result, (bool)0);
39573 }
39574 {
39575 if (temp3)
39576 delete arg3;
39577 }
39578 {
39579 if (temp5)
39580 delete arg5;
39581 }
39582 return resultobj;
39583 fail:
39584 {
39585 if (temp3)
39586 delete arg3;
39587 }
39588 {
39589 if (temp5)
39590 delete arg5;
39591 }
39592 return NULL;
39593 }
39594
39595
39596 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39597 PyObject *resultobj = 0;
39598 wxMenu *arg1 = (wxMenu *) 0 ;
39599 int arg2 ;
39600 wxMenuItem *result = 0 ;
39601 void *argp1 = 0 ;
39602 int res1 = 0 ;
39603 int val2 ;
39604 int ecode2 = 0 ;
39605 PyObject * obj0 = 0 ;
39606 PyObject * obj1 = 0 ;
39607 char * kwnames[] = {
39608 (char *) "self",(char *) "id", NULL
39609 };
39610
39611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39613 if (!SWIG_IsOK(res1)) {
39614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39615 }
39616 arg1 = reinterpret_cast< wxMenu * >(argp1);
39617 ecode2 = SWIG_AsVal_int(obj1, &val2);
39618 if (!SWIG_IsOK(ecode2)) {
39619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39620 }
39621 arg2 = static_cast< int >(val2);
39622 {
39623 PyThreadState* __tstate = wxPyBeginAllowThreads();
39624 result = (wxMenuItem *)(arg1)->Remove(arg2);
39625 wxPyEndAllowThreads(__tstate);
39626 if (PyErr_Occurred()) SWIG_fail;
39627 }
39628 {
39629 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39630 }
39631 return resultobj;
39632 fail:
39633 return NULL;
39634 }
39635
39636
39637 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39638 PyObject *resultobj = 0;
39639 wxMenu *arg1 = (wxMenu *) 0 ;
39640 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39641 wxMenuItem *result = 0 ;
39642 void *argp1 = 0 ;
39643 int res1 = 0 ;
39644 void *argp2 = 0 ;
39645 int res2 = 0 ;
39646 PyObject * obj0 = 0 ;
39647 PyObject * obj1 = 0 ;
39648 char * kwnames[] = {
39649 (char *) "self",(char *) "item", NULL
39650 };
39651
39652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39654 if (!SWIG_IsOK(res1)) {
39655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39656 }
39657 arg1 = reinterpret_cast< wxMenu * >(argp1);
39658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39659 if (!SWIG_IsOK(res2)) {
39660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39661 }
39662 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39663 {
39664 PyThreadState* __tstate = wxPyBeginAllowThreads();
39665 result = (wxMenuItem *)(arg1)->Remove(arg2);
39666 wxPyEndAllowThreads(__tstate);
39667 if (PyErr_Occurred()) SWIG_fail;
39668 }
39669 {
39670 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39671 }
39672 return resultobj;
39673 fail:
39674 return NULL;
39675 }
39676
39677
39678 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39679 PyObject *resultobj = 0;
39680 wxMenu *arg1 = (wxMenu *) 0 ;
39681 int arg2 ;
39682 bool result;
39683 void *argp1 = 0 ;
39684 int res1 = 0 ;
39685 int val2 ;
39686 int ecode2 = 0 ;
39687 PyObject * obj0 = 0 ;
39688 PyObject * obj1 = 0 ;
39689 char * kwnames[] = {
39690 (char *) "self",(char *) "id", NULL
39691 };
39692
39693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39695 if (!SWIG_IsOK(res1)) {
39696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39697 }
39698 arg1 = reinterpret_cast< wxMenu * >(argp1);
39699 ecode2 = SWIG_AsVal_int(obj1, &val2);
39700 if (!SWIG_IsOK(ecode2)) {
39701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39702 }
39703 arg2 = static_cast< int >(val2);
39704 {
39705 PyThreadState* __tstate = wxPyBeginAllowThreads();
39706 result = (bool)(arg1)->Delete(arg2);
39707 wxPyEndAllowThreads(__tstate);
39708 if (PyErr_Occurred()) SWIG_fail;
39709 }
39710 {
39711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39712 }
39713 return resultobj;
39714 fail:
39715 return NULL;
39716 }
39717
39718
39719 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39720 PyObject *resultobj = 0;
39721 wxMenu *arg1 = (wxMenu *) 0 ;
39722 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39723 bool result;
39724 void *argp1 = 0 ;
39725 int res1 = 0 ;
39726 void *argp2 = 0 ;
39727 int res2 = 0 ;
39728 PyObject * obj0 = 0 ;
39729 PyObject * obj1 = 0 ;
39730 char * kwnames[] = {
39731 (char *) "self",(char *) "item", NULL
39732 };
39733
39734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39736 if (!SWIG_IsOK(res1)) {
39737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39738 }
39739 arg1 = reinterpret_cast< wxMenu * >(argp1);
39740 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39741 if (!SWIG_IsOK(res2)) {
39742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39743 }
39744 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39745 {
39746 PyThreadState* __tstate = wxPyBeginAllowThreads();
39747 result = (bool)(arg1)->Delete(arg2);
39748 wxPyEndAllowThreads(__tstate);
39749 if (PyErr_Occurred()) SWIG_fail;
39750 }
39751 {
39752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39753 }
39754 return resultobj;
39755 fail:
39756 return NULL;
39757 }
39758
39759
39760 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39761 PyObject *resultobj = 0;
39762 wxMenu *arg1 = (wxMenu *) 0 ;
39763 void *argp1 = 0 ;
39764 int res1 = 0 ;
39765 PyObject *swig_obj[1] ;
39766
39767 if (!args) SWIG_fail;
39768 swig_obj[0] = args;
39769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39770 if (!SWIG_IsOK(res1)) {
39771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39772 }
39773 arg1 = reinterpret_cast< wxMenu * >(argp1);
39774 {
39775 PyThreadState* __tstate = wxPyBeginAllowThreads();
39776 wxMenu_Destroy(arg1);
39777 wxPyEndAllowThreads(__tstate);
39778 if (PyErr_Occurred()) SWIG_fail;
39779 }
39780 resultobj = SWIG_Py_Void();
39781 return resultobj;
39782 fail:
39783 return NULL;
39784 }
39785
39786
39787 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39788 PyObject *resultobj = 0;
39789 wxMenu *arg1 = (wxMenu *) 0 ;
39790 int arg2 ;
39791 bool result;
39792 void *argp1 = 0 ;
39793 int res1 = 0 ;
39794 int val2 ;
39795 int ecode2 = 0 ;
39796 PyObject * obj0 = 0 ;
39797 PyObject * obj1 = 0 ;
39798 char * kwnames[] = {
39799 (char *) "self",(char *) "id", NULL
39800 };
39801
39802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39804 if (!SWIG_IsOK(res1)) {
39805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39806 }
39807 arg1 = reinterpret_cast< wxMenu * >(argp1);
39808 ecode2 = SWIG_AsVal_int(obj1, &val2);
39809 if (!SWIG_IsOK(ecode2)) {
39810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39811 }
39812 arg2 = static_cast< int >(val2);
39813 {
39814 PyThreadState* __tstate = wxPyBeginAllowThreads();
39815 result = (bool)(arg1)->Destroy(arg2);
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 {
39820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39821 }
39822 return resultobj;
39823 fail:
39824 return NULL;
39825 }
39826
39827
39828 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39829 PyObject *resultobj = 0;
39830 wxMenu *arg1 = (wxMenu *) 0 ;
39831 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39832 bool result;
39833 void *argp1 = 0 ;
39834 int res1 = 0 ;
39835 void *argp2 = 0 ;
39836 int res2 = 0 ;
39837 PyObject * obj0 = 0 ;
39838 PyObject * obj1 = 0 ;
39839 char * kwnames[] = {
39840 (char *) "self",(char *) "item", NULL
39841 };
39842
39843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39845 if (!SWIG_IsOK(res1)) {
39846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39847 }
39848 arg1 = reinterpret_cast< wxMenu * >(argp1);
39849 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39850 if (!SWIG_IsOK(res2)) {
39851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39852 }
39853 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39854 {
39855 PyThreadState* __tstate = wxPyBeginAllowThreads();
39856 result = (bool)(arg1)->Destroy(arg2);
39857 wxPyEndAllowThreads(__tstate);
39858 if (PyErr_Occurred()) SWIG_fail;
39859 }
39860 {
39861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39862 }
39863 return resultobj;
39864 fail:
39865 return NULL;
39866 }
39867
39868
39869 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39870 PyObject *resultobj = 0;
39871 wxMenu *arg1 = (wxMenu *) 0 ;
39872 size_t result;
39873 void *argp1 = 0 ;
39874 int res1 = 0 ;
39875 PyObject *swig_obj[1] ;
39876
39877 if (!args) SWIG_fail;
39878 swig_obj[0] = args;
39879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39880 if (!SWIG_IsOK(res1)) {
39881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39882 }
39883 arg1 = reinterpret_cast< wxMenu * >(argp1);
39884 {
39885 PyThreadState* __tstate = wxPyBeginAllowThreads();
39886 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39887 wxPyEndAllowThreads(__tstate);
39888 if (PyErr_Occurred()) SWIG_fail;
39889 }
39890 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39891 return resultobj;
39892 fail:
39893 return NULL;
39894 }
39895
39896
39897 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39898 PyObject *resultobj = 0;
39899 wxMenu *arg1 = (wxMenu *) 0 ;
39900 PyObject *result = 0 ;
39901 void *argp1 = 0 ;
39902 int res1 = 0 ;
39903 PyObject *swig_obj[1] ;
39904
39905 if (!args) SWIG_fail;
39906 swig_obj[0] = args;
39907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39908 if (!SWIG_IsOK(res1)) {
39909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39910 }
39911 arg1 = reinterpret_cast< wxMenu * >(argp1);
39912 {
39913 PyThreadState* __tstate = wxPyBeginAllowThreads();
39914 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39915 wxPyEndAllowThreads(__tstate);
39916 if (PyErr_Occurred()) SWIG_fail;
39917 }
39918 resultobj = result;
39919 return resultobj;
39920 fail:
39921 return NULL;
39922 }
39923
39924
39925 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39926 PyObject *resultobj = 0;
39927 wxMenu *arg1 = (wxMenu *) 0 ;
39928 wxString *arg2 = 0 ;
39929 int result;
39930 void *argp1 = 0 ;
39931 int res1 = 0 ;
39932 bool temp2 = false ;
39933 PyObject * obj0 = 0 ;
39934 PyObject * obj1 = 0 ;
39935 char * kwnames[] = {
39936 (char *) "self",(char *) "item", NULL
39937 };
39938
39939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39941 if (!SWIG_IsOK(res1)) {
39942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39943 }
39944 arg1 = reinterpret_cast< wxMenu * >(argp1);
39945 {
39946 arg2 = wxString_in_helper(obj1);
39947 if (arg2 == NULL) SWIG_fail;
39948 temp2 = true;
39949 }
39950 {
39951 PyThreadState* __tstate = wxPyBeginAllowThreads();
39952 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39953 wxPyEndAllowThreads(__tstate);
39954 if (PyErr_Occurred()) SWIG_fail;
39955 }
39956 resultobj = SWIG_From_int(static_cast< int >(result));
39957 {
39958 if (temp2)
39959 delete arg2;
39960 }
39961 return resultobj;
39962 fail:
39963 {
39964 if (temp2)
39965 delete arg2;
39966 }
39967 return NULL;
39968 }
39969
39970
39971 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39972 PyObject *resultobj = 0;
39973 wxMenu *arg1 = (wxMenu *) 0 ;
39974 int arg2 ;
39975 wxMenuItem *result = 0 ;
39976 void *argp1 = 0 ;
39977 int res1 = 0 ;
39978 int val2 ;
39979 int ecode2 = 0 ;
39980 PyObject * obj0 = 0 ;
39981 PyObject * obj1 = 0 ;
39982 char * kwnames[] = {
39983 (char *) "self",(char *) "id", NULL
39984 };
39985
39986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39988 if (!SWIG_IsOK(res1)) {
39989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39990 }
39991 arg1 = reinterpret_cast< wxMenu * >(argp1);
39992 ecode2 = SWIG_AsVal_int(obj1, &val2);
39993 if (!SWIG_IsOK(ecode2)) {
39994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39995 }
39996 arg2 = static_cast< int >(val2);
39997 {
39998 PyThreadState* __tstate = wxPyBeginAllowThreads();
39999 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 {
40004 resultobj = wxPyMake_wxObject(result, (bool)0);
40005 }
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40013 PyObject *resultobj = 0;
40014 wxMenu *arg1 = (wxMenu *) 0 ;
40015 size_t arg2 ;
40016 wxMenuItem *result = 0 ;
40017 void *argp1 = 0 ;
40018 int res1 = 0 ;
40019 size_t val2 ;
40020 int ecode2 = 0 ;
40021 PyObject * obj0 = 0 ;
40022 PyObject * obj1 = 0 ;
40023 char * kwnames[] = {
40024 (char *) "self",(char *) "position", NULL
40025 };
40026
40027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40029 if (!SWIG_IsOK(res1)) {
40030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40031 }
40032 arg1 = reinterpret_cast< wxMenu * >(argp1);
40033 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40034 if (!SWIG_IsOK(ecode2)) {
40035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40036 }
40037 arg2 = static_cast< size_t >(val2);
40038 {
40039 PyThreadState* __tstate = wxPyBeginAllowThreads();
40040 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40041 wxPyEndAllowThreads(__tstate);
40042 if (PyErr_Occurred()) SWIG_fail;
40043 }
40044 {
40045 resultobj = wxPyMake_wxObject(result, (bool)0);
40046 }
40047 return resultobj;
40048 fail:
40049 return NULL;
40050 }
40051
40052
40053 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40054 PyObject *resultobj = 0;
40055 wxMenu *arg1 = (wxMenu *) 0 ;
40056 int arg2 ;
40057 bool arg3 ;
40058 void *argp1 = 0 ;
40059 int res1 = 0 ;
40060 int val2 ;
40061 int ecode2 = 0 ;
40062 bool val3 ;
40063 int ecode3 = 0 ;
40064 PyObject * obj0 = 0 ;
40065 PyObject * obj1 = 0 ;
40066 PyObject * obj2 = 0 ;
40067 char * kwnames[] = {
40068 (char *) "self",(char *) "id",(char *) "enable", NULL
40069 };
40070
40071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40073 if (!SWIG_IsOK(res1)) {
40074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40075 }
40076 arg1 = reinterpret_cast< wxMenu * >(argp1);
40077 ecode2 = SWIG_AsVal_int(obj1, &val2);
40078 if (!SWIG_IsOK(ecode2)) {
40079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40080 }
40081 arg2 = static_cast< int >(val2);
40082 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40083 if (!SWIG_IsOK(ecode3)) {
40084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40085 }
40086 arg3 = static_cast< bool >(val3);
40087 {
40088 PyThreadState* __tstate = wxPyBeginAllowThreads();
40089 (arg1)->Enable(arg2,arg3);
40090 wxPyEndAllowThreads(__tstate);
40091 if (PyErr_Occurred()) SWIG_fail;
40092 }
40093 resultobj = SWIG_Py_Void();
40094 return resultobj;
40095 fail:
40096 return NULL;
40097 }
40098
40099
40100 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40101 PyObject *resultobj = 0;
40102 wxMenu *arg1 = (wxMenu *) 0 ;
40103 int arg2 ;
40104 bool result;
40105 void *argp1 = 0 ;
40106 int res1 = 0 ;
40107 int val2 ;
40108 int ecode2 = 0 ;
40109 PyObject * obj0 = 0 ;
40110 PyObject * obj1 = 0 ;
40111 char * kwnames[] = {
40112 (char *) "self",(char *) "id", NULL
40113 };
40114
40115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40117 if (!SWIG_IsOK(res1)) {
40118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40119 }
40120 arg1 = reinterpret_cast< wxMenu * >(argp1);
40121 ecode2 = SWIG_AsVal_int(obj1, &val2);
40122 if (!SWIG_IsOK(ecode2)) {
40123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40124 }
40125 arg2 = static_cast< int >(val2);
40126 {
40127 PyThreadState* __tstate = wxPyBeginAllowThreads();
40128 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40129 wxPyEndAllowThreads(__tstate);
40130 if (PyErr_Occurred()) SWIG_fail;
40131 }
40132 {
40133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40134 }
40135 return resultobj;
40136 fail:
40137 return NULL;
40138 }
40139
40140
40141 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40142 PyObject *resultobj = 0;
40143 wxMenu *arg1 = (wxMenu *) 0 ;
40144 int arg2 ;
40145 bool arg3 ;
40146 void *argp1 = 0 ;
40147 int res1 = 0 ;
40148 int val2 ;
40149 int ecode2 = 0 ;
40150 bool val3 ;
40151 int ecode3 = 0 ;
40152 PyObject * obj0 = 0 ;
40153 PyObject * obj1 = 0 ;
40154 PyObject * obj2 = 0 ;
40155 char * kwnames[] = {
40156 (char *) "self",(char *) "id",(char *) "check", NULL
40157 };
40158
40159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40161 if (!SWIG_IsOK(res1)) {
40162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40163 }
40164 arg1 = reinterpret_cast< wxMenu * >(argp1);
40165 ecode2 = SWIG_AsVal_int(obj1, &val2);
40166 if (!SWIG_IsOK(ecode2)) {
40167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40168 }
40169 arg2 = static_cast< int >(val2);
40170 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40171 if (!SWIG_IsOK(ecode3)) {
40172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40173 }
40174 arg3 = static_cast< bool >(val3);
40175 {
40176 PyThreadState* __tstate = wxPyBeginAllowThreads();
40177 (arg1)->Check(arg2,arg3);
40178 wxPyEndAllowThreads(__tstate);
40179 if (PyErr_Occurred()) SWIG_fail;
40180 }
40181 resultobj = SWIG_Py_Void();
40182 return resultobj;
40183 fail:
40184 return NULL;
40185 }
40186
40187
40188 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40189 PyObject *resultobj = 0;
40190 wxMenu *arg1 = (wxMenu *) 0 ;
40191 int arg2 ;
40192 bool result;
40193 void *argp1 = 0 ;
40194 int res1 = 0 ;
40195 int val2 ;
40196 int ecode2 = 0 ;
40197 PyObject * obj0 = 0 ;
40198 PyObject * obj1 = 0 ;
40199 char * kwnames[] = {
40200 (char *) "self",(char *) "id", NULL
40201 };
40202
40203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40205 if (!SWIG_IsOK(res1)) {
40206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40207 }
40208 arg1 = reinterpret_cast< wxMenu * >(argp1);
40209 ecode2 = SWIG_AsVal_int(obj1, &val2);
40210 if (!SWIG_IsOK(ecode2)) {
40211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40212 }
40213 arg2 = static_cast< int >(val2);
40214 {
40215 PyThreadState* __tstate = wxPyBeginAllowThreads();
40216 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40217 wxPyEndAllowThreads(__tstate);
40218 if (PyErr_Occurred()) SWIG_fail;
40219 }
40220 {
40221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40222 }
40223 return resultobj;
40224 fail:
40225 return NULL;
40226 }
40227
40228
40229 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40230 PyObject *resultobj = 0;
40231 wxMenu *arg1 = (wxMenu *) 0 ;
40232 int arg2 ;
40233 wxString *arg3 = 0 ;
40234 void *argp1 = 0 ;
40235 int res1 = 0 ;
40236 int val2 ;
40237 int ecode2 = 0 ;
40238 bool temp3 = false ;
40239 PyObject * obj0 = 0 ;
40240 PyObject * obj1 = 0 ;
40241 PyObject * obj2 = 0 ;
40242 char * kwnames[] = {
40243 (char *) "self",(char *) "id",(char *) "label", NULL
40244 };
40245
40246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40248 if (!SWIG_IsOK(res1)) {
40249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40250 }
40251 arg1 = reinterpret_cast< wxMenu * >(argp1);
40252 ecode2 = SWIG_AsVal_int(obj1, &val2);
40253 if (!SWIG_IsOK(ecode2)) {
40254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40255 }
40256 arg2 = static_cast< int >(val2);
40257 {
40258 arg3 = wxString_in_helper(obj2);
40259 if (arg3 == NULL) SWIG_fail;
40260 temp3 = true;
40261 }
40262 {
40263 PyThreadState* __tstate = wxPyBeginAllowThreads();
40264 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40265 wxPyEndAllowThreads(__tstate);
40266 if (PyErr_Occurred()) SWIG_fail;
40267 }
40268 resultobj = SWIG_Py_Void();
40269 {
40270 if (temp3)
40271 delete arg3;
40272 }
40273 return resultobj;
40274 fail:
40275 {
40276 if (temp3)
40277 delete arg3;
40278 }
40279 return NULL;
40280 }
40281
40282
40283 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40284 PyObject *resultobj = 0;
40285 wxMenu *arg1 = (wxMenu *) 0 ;
40286 int arg2 ;
40287 wxString result;
40288 void *argp1 = 0 ;
40289 int res1 = 0 ;
40290 int val2 ;
40291 int ecode2 = 0 ;
40292 PyObject * obj0 = 0 ;
40293 PyObject * obj1 = 0 ;
40294 char * kwnames[] = {
40295 (char *) "self",(char *) "id", NULL
40296 };
40297
40298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40300 if (!SWIG_IsOK(res1)) {
40301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40302 }
40303 arg1 = reinterpret_cast< wxMenu * >(argp1);
40304 ecode2 = SWIG_AsVal_int(obj1, &val2);
40305 if (!SWIG_IsOK(ecode2)) {
40306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40307 }
40308 arg2 = static_cast< int >(val2);
40309 {
40310 PyThreadState* __tstate = wxPyBeginAllowThreads();
40311 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40312 wxPyEndAllowThreads(__tstate);
40313 if (PyErr_Occurred()) SWIG_fail;
40314 }
40315 {
40316 #if wxUSE_UNICODE
40317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40318 #else
40319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40320 #endif
40321 }
40322 return resultobj;
40323 fail:
40324 return NULL;
40325 }
40326
40327
40328 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40329 PyObject *resultobj = 0;
40330 wxMenu *arg1 = (wxMenu *) 0 ;
40331 int arg2 ;
40332 wxString *arg3 = 0 ;
40333 void *argp1 = 0 ;
40334 int res1 = 0 ;
40335 int val2 ;
40336 int ecode2 = 0 ;
40337 bool temp3 = false ;
40338 PyObject * obj0 = 0 ;
40339 PyObject * obj1 = 0 ;
40340 PyObject * obj2 = 0 ;
40341 char * kwnames[] = {
40342 (char *) "self",(char *) "id",(char *) "helpString", NULL
40343 };
40344
40345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40347 if (!SWIG_IsOK(res1)) {
40348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40349 }
40350 arg1 = reinterpret_cast< wxMenu * >(argp1);
40351 ecode2 = SWIG_AsVal_int(obj1, &val2);
40352 if (!SWIG_IsOK(ecode2)) {
40353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40354 }
40355 arg2 = static_cast< int >(val2);
40356 {
40357 arg3 = wxString_in_helper(obj2);
40358 if (arg3 == NULL) SWIG_fail;
40359 temp3 = true;
40360 }
40361 {
40362 PyThreadState* __tstate = wxPyBeginAllowThreads();
40363 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 resultobj = SWIG_Py_Void();
40368 {
40369 if (temp3)
40370 delete arg3;
40371 }
40372 return resultobj;
40373 fail:
40374 {
40375 if (temp3)
40376 delete arg3;
40377 }
40378 return NULL;
40379 }
40380
40381
40382 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40383 PyObject *resultobj = 0;
40384 wxMenu *arg1 = (wxMenu *) 0 ;
40385 int arg2 ;
40386 wxString result;
40387 void *argp1 = 0 ;
40388 int res1 = 0 ;
40389 int val2 ;
40390 int ecode2 = 0 ;
40391 PyObject * obj0 = 0 ;
40392 PyObject * obj1 = 0 ;
40393 char * kwnames[] = {
40394 (char *) "self",(char *) "id", NULL
40395 };
40396
40397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40399 if (!SWIG_IsOK(res1)) {
40400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40401 }
40402 arg1 = reinterpret_cast< wxMenu * >(argp1);
40403 ecode2 = SWIG_AsVal_int(obj1, &val2);
40404 if (!SWIG_IsOK(ecode2)) {
40405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40406 }
40407 arg2 = static_cast< int >(val2);
40408 {
40409 PyThreadState* __tstate = wxPyBeginAllowThreads();
40410 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40411 wxPyEndAllowThreads(__tstate);
40412 if (PyErr_Occurred()) SWIG_fail;
40413 }
40414 {
40415 #if wxUSE_UNICODE
40416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40417 #else
40418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40419 #endif
40420 }
40421 return resultobj;
40422 fail:
40423 return NULL;
40424 }
40425
40426
40427 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40428 PyObject *resultobj = 0;
40429 wxMenu *arg1 = (wxMenu *) 0 ;
40430 wxString *arg2 = 0 ;
40431 void *argp1 = 0 ;
40432 int res1 = 0 ;
40433 bool temp2 = false ;
40434 PyObject * obj0 = 0 ;
40435 PyObject * obj1 = 0 ;
40436 char * kwnames[] = {
40437 (char *) "self",(char *) "title", NULL
40438 };
40439
40440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40442 if (!SWIG_IsOK(res1)) {
40443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40444 }
40445 arg1 = reinterpret_cast< wxMenu * >(argp1);
40446 {
40447 arg2 = wxString_in_helper(obj1);
40448 if (arg2 == NULL) SWIG_fail;
40449 temp2 = true;
40450 }
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 (arg1)->SetTitle((wxString const &)*arg2);
40454 wxPyEndAllowThreads(__tstate);
40455 if (PyErr_Occurred()) SWIG_fail;
40456 }
40457 resultobj = SWIG_Py_Void();
40458 {
40459 if (temp2)
40460 delete arg2;
40461 }
40462 return resultobj;
40463 fail:
40464 {
40465 if (temp2)
40466 delete arg2;
40467 }
40468 return NULL;
40469 }
40470
40471
40472 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40473 PyObject *resultobj = 0;
40474 wxMenu *arg1 = (wxMenu *) 0 ;
40475 wxString result;
40476 void *argp1 = 0 ;
40477 int res1 = 0 ;
40478 PyObject *swig_obj[1] ;
40479
40480 if (!args) SWIG_fail;
40481 swig_obj[0] = args;
40482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40483 if (!SWIG_IsOK(res1)) {
40484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40485 }
40486 arg1 = reinterpret_cast< wxMenu * >(argp1);
40487 {
40488 PyThreadState* __tstate = wxPyBeginAllowThreads();
40489 result = ((wxMenu const *)arg1)->GetTitle();
40490 wxPyEndAllowThreads(__tstate);
40491 if (PyErr_Occurred()) SWIG_fail;
40492 }
40493 {
40494 #if wxUSE_UNICODE
40495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40496 #else
40497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40498 #endif
40499 }
40500 return resultobj;
40501 fail:
40502 return NULL;
40503 }
40504
40505
40506 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40507 PyObject *resultobj = 0;
40508 wxMenu *arg1 = (wxMenu *) 0 ;
40509 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40510 void *argp1 = 0 ;
40511 int res1 = 0 ;
40512 void *argp2 = 0 ;
40513 int res2 = 0 ;
40514 PyObject * obj0 = 0 ;
40515 PyObject * obj1 = 0 ;
40516 char * kwnames[] = {
40517 (char *) "self",(char *) "handler", NULL
40518 };
40519
40520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40522 if (!SWIG_IsOK(res1)) {
40523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40524 }
40525 arg1 = reinterpret_cast< wxMenu * >(argp1);
40526 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40527 if (!SWIG_IsOK(res2)) {
40528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40529 }
40530 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40531 {
40532 PyThreadState* __tstate = wxPyBeginAllowThreads();
40533 (arg1)->SetEventHandler(arg2);
40534 wxPyEndAllowThreads(__tstate);
40535 if (PyErr_Occurred()) SWIG_fail;
40536 }
40537 resultobj = SWIG_Py_Void();
40538 return resultobj;
40539 fail:
40540 return NULL;
40541 }
40542
40543
40544 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40545 PyObject *resultobj = 0;
40546 wxMenu *arg1 = (wxMenu *) 0 ;
40547 wxEvtHandler *result = 0 ;
40548 void *argp1 = 0 ;
40549 int res1 = 0 ;
40550 PyObject *swig_obj[1] ;
40551
40552 if (!args) SWIG_fail;
40553 swig_obj[0] = args;
40554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40555 if (!SWIG_IsOK(res1)) {
40556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40557 }
40558 arg1 = reinterpret_cast< wxMenu * >(argp1);
40559 {
40560 PyThreadState* __tstate = wxPyBeginAllowThreads();
40561 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40562 wxPyEndAllowThreads(__tstate);
40563 if (PyErr_Occurred()) SWIG_fail;
40564 }
40565 {
40566 resultobj = wxPyMake_wxObject(result, 0);
40567 }
40568 return resultobj;
40569 fail:
40570 return NULL;
40571 }
40572
40573
40574 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40575 PyObject *resultobj = 0;
40576 wxMenu *arg1 = (wxMenu *) 0 ;
40577 wxWindow *arg2 = (wxWindow *) 0 ;
40578 void *argp1 = 0 ;
40579 int res1 = 0 ;
40580 void *argp2 = 0 ;
40581 int res2 = 0 ;
40582 PyObject * obj0 = 0 ;
40583 PyObject * obj1 = 0 ;
40584 char * kwnames[] = {
40585 (char *) "self",(char *) "win", NULL
40586 };
40587
40588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40590 if (!SWIG_IsOK(res1)) {
40591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40592 }
40593 arg1 = reinterpret_cast< wxMenu * >(argp1);
40594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40595 if (!SWIG_IsOK(res2)) {
40596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40597 }
40598 arg2 = reinterpret_cast< wxWindow * >(argp2);
40599 {
40600 PyThreadState* __tstate = wxPyBeginAllowThreads();
40601 (arg1)->SetInvokingWindow(arg2);
40602 wxPyEndAllowThreads(__tstate);
40603 if (PyErr_Occurred()) SWIG_fail;
40604 }
40605 resultobj = SWIG_Py_Void();
40606 return resultobj;
40607 fail:
40608 return NULL;
40609 }
40610
40611
40612 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40613 PyObject *resultobj = 0;
40614 wxMenu *arg1 = (wxMenu *) 0 ;
40615 wxWindow *result = 0 ;
40616 void *argp1 = 0 ;
40617 int res1 = 0 ;
40618 PyObject *swig_obj[1] ;
40619
40620 if (!args) SWIG_fail;
40621 swig_obj[0] = args;
40622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40623 if (!SWIG_IsOK(res1)) {
40624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40625 }
40626 arg1 = reinterpret_cast< wxMenu * >(argp1);
40627 {
40628 PyThreadState* __tstate = wxPyBeginAllowThreads();
40629 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40630 wxPyEndAllowThreads(__tstate);
40631 if (PyErr_Occurred()) SWIG_fail;
40632 }
40633 {
40634 resultobj = wxPyMake_wxObject(result, 0);
40635 }
40636 return resultobj;
40637 fail:
40638 return NULL;
40639 }
40640
40641
40642 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40643 PyObject *resultobj = 0;
40644 wxMenu *arg1 = (wxMenu *) 0 ;
40645 long result;
40646 void *argp1 = 0 ;
40647 int res1 = 0 ;
40648 PyObject *swig_obj[1] ;
40649
40650 if (!args) SWIG_fail;
40651 swig_obj[0] = args;
40652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40653 if (!SWIG_IsOK(res1)) {
40654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40655 }
40656 arg1 = reinterpret_cast< wxMenu * >(argp1);
40657 {
40658 PyThreadState* __tstate = wxPyBeginAllowThreads();
40659 result = (long)((wxMenu const *)arg1)->GetStyle();
40660 wxPyEndAllowThreads(__tstate);
40661 if (PyErr_Occurred()) SWIG_fail;
40662 }
40663 resultobj = SWIG_From_long(static_cast< long >(result));
40664 return resultobj;
40665 fail:
40666 return NULL;
40667 }
40668
40669
40670 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40671 PyObject *resultobj = 0;
40672 wxMenu *arg1 = (wxMenu *) 0 ;
40673 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40674 void *argp1 = 0 ;
40675 int res1 = 0 ;
40676 void *argp2 = 0 ;
40677 int res2 = 0 ;
40678 PyObject * obj0 = 0 ;
40679 PyObject * obj1 = 0 ;
40680 char * kwnames[] = {
40681 (char *) "self",(char *) "source", NULL
40682 };
40683
40684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40686 if (!SWIG_IsOK(res1)) {
40687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40688 }
40689 arg1 = reinterpret_cast< wxMenu * >(argp1);
40690 if (obj1) {
40691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40692 if (!SWIG_IsOK(res2)) {
40693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40694 }
40695 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40696 }
40697 {
40698 PyThreadState* __tstate = wxPyBeginAllowThreads();
40699 (arg1)->UpdateUI(arg2);
40700 wxPyEndAllowThreads(__tstate);
40701 if (PyErr_Occurred()) SWIG_fail;
40702 }
40703 resultobj = SWIG_Py_Void();
40704 return resultobj;
40705 fail:
40706 return NULL;
40707 }
40708
40709
40710 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40711 PyObject *resultobj = 0;
40712 wxMenu *arg1 = (wxMenu *) 0 ;
40713 wxMenuBar *result = 0 ;
40714 void *argp1 = 0 ;
40715 int res1 = 0 ;
40716 PyObject *swig_obj[1] ;
40717
40718 if (!args) SWIG_fail;
40719 swig_obj[0] = args;
40720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40721 if (!SWIG_IsOK(res1)) {
40722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40723 }
40724 arg1 = reinterpret_cast< wxMenu * >(argp1);
40725 {
40726 PyThreadState* __tstate = wxPyBeginAllowThreads();
40727 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40728 wxPyEndAllowThreads(__tstate);
40729 if (PyErr_Occurred()) SWIG_fail;
40730 }
40731 {
40732 resultobj = wxPyMake_wxObject(result, (bool)0);
40733 }
40734 return resultobj;
40735 fail:
40736 return NULL;
40737 }
40738
40739
40740 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40741 PyObject *resultobj = 0;
40742 wxMenu *arg1 = (wxMenu *) 0 ;
40743 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40744 void *argp1 = 0 ;
40745 int res1 = 0 ;
40746 void *argp2 = 0 ;
40747 int res2 = 0 ;
40748 PyObject * obj0 = 0 ;
40749 PyObject * obj1 = 0 ;
40750 char * kwnames[] = {
40751 (char *) "self",(char *) "menubar", NULL
40752 };
40753
40754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40756 if (!SWIG_IsOK(res1)) {
40757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40758 }
40759 arg1 = reinterpret_cast< wxMenu * >(argp1);
40760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40761 if (!SWIG_IsOK(res2)) {
40762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40763 }
40764 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40765 {
40766 PyThreadState* __tstate = wxPyBeginAllowThreads();
40767 (arg1)->Attach(arg2);
40768 wxPyEndAllowThreads(__tstate);
40769 if (PyErr_Occurred()) SWIG_fail;
40770 }
40771 resultobj = SWIG_Py_Void();
40772 return resultobj;
40773 fail:
40774 return NULL;
40775 }
40776
40777
40778 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40779 PyObject *resultobj = 0;
40780 wxMenu *arg1 = (wxMenu *) 0 ;
40781 void *argp1 = 0 ;
40782 int res1 = 0 ;
40783 PyObject *swig_obj[1] ;
40784
40785 if (!args) SWIG_fail;
40786 swig_obj[0] = args;
40787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40788 if (!SWIG_IsOK(res1)) {
40789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40790 }
40791 arg1 = reinterpret_cast< wxMenu * >(argp1);
40792 {
40793 PyThreadState* __tstate = wxPyBeginAllowThreads();
40794 (arg1)->Detach();
40795 wxPyEndAllowThreads(__tstate);
40796 if (PyErr_Occurred()) SWIG_fail;
40797 }
40798 resultobj = SWIG_Py_Void();
40799 return resultobj;
40800 fail:
40801 return NULL;
40802 }
40803
40804
40805 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40806 PyObject *resultobj = 0;
40807 wxMenu *arg1 = (wxMenu *) 0 ;
40808 bool result;
40809 void *argp1 = 0 ;
40810 int res1 = 0 ;
40811 PyObject *swig_obj[1] ;
40812
40813 if (!args) SWIG_fail;
40814 swig_obj[0] = args;
40815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40816 if (!SWIG_IsOK(res1)) {
40817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40818 }
40819 arg1 = reinterpret_cast< wxMenu * >(argp1);
40820 {
40821 PyThreadState* __tstate = wxPyBeginAllowThreads();
40822 result = (bool)((wxMenu const *)arg1)->IsAttached();
40823 wxPyEndAllowThreads(__tstate);
40824 if (PyErr_Occurred()) SWIG_fail;
40825 }
40826 {
40827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40828 }
40829 return resultobj;
40830 fail:
40831 return NULL;
40832 }
40833
40834
40835 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40836 PyObject *resultobj = 0;
40837 wxMenu *arg1 = (wxMenu *) 0 ;
40838 wxMenu *arg2 = (wxMenu *) 0 ;
40839 void *argp1 = 0 ;
40840 int res1 = 0 ;
40841 void *argp2 = 0 ;
40842 int res2 = 0 ;
40843 PyObject * obj0 = 0 ;
40844 PyObject * obj1 = 0 ;
40845 char * kwnames[] = {
40846 (char *) "self",(char *) "parent", NULL
40847 };
40848
40849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40851 if (!SWIG_IsOK(res1)) {
40852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40853 }
40854 arg1 = reinterpret_cast< wxMenu * >(argp1);
40855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40856 if (!SWIG_IsOK(res2)) {
40857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40858 }
40859 arg2 = reinterpret_cast< wxMenu * >(argp2);
40860 {
40861 PyThreadState* __tstate = wxPyBeginAllowThreads();
40862 (arg1)->SetParent(arg2);
40863 wxPyEndAllowThreads(__tstate);
40864 if (PyErr_Occurred()) SWIG_fail;
40865 }
40866 resultobj = SWIG_Py_Void();
40867 return resultobj;
40868 fail:
40869 return NULL;
40870 }
40871
40872
40873 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40874 PyObject *resultobj = 0;
40875 wxMenu *arg1 = (wxMenu *) 0 ;
40876 wxMenu *result = 0 ;
40877 void *argp1 = 0 ;
40878 int res1 = 0 ;
40879 PyObject *swig_obj[1] ;
40880
40881 if (!args) SWIG_fail;
40882 swig_obj[0] = args;
40883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40884 if (!SWIG_IsOK(res1)) {
40885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40886 }
40887 arg1 = reinterpret_cast< wxMenu * >(argp1);
40888 {
40889 PyThreadState* __tstate = wxPyBeginAllowThreads();
40890 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40891 wxPyEndAllowThreads(__tstate);
40892 if (PyErr_Occurred()) SWIG_fail;
40893 }
40894 {
40895 resultobj = wxPyMake_wxObject(result, 0);
40896 }
40897 return resultobj;
40898 fail:
40899 return NULL;
40900 }
40901
40902
40903 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40904 PyObject *obj;
40905 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40906 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40907 return SWIG_Py_Void();
40908 }
40909
40910 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40911 return SWIG_Python_InitShadowInstance(args);
40912 }
40913
40914 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40915 PyObject *resultobj = 0;
40916 long arg1 = (long) 0 ;
40917 wxMenuBar *result = 0 ;
40918 long val1 ;
40919 int ecode1 = 0 ;
40920 PyObject * obj0 = 0 ;
40921 char * kwnames[] = {
40922 (char *) "style", NULL
40923 };
40924
40925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40926 if (obj0) {
40927 ecode1 = SWIG_AsVal_long(obj0, &val1);
40928 if (!SWIG_IsOK(ecode1)) {
40929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40930 }
40931 arg1 = static_cast< long >(val1);
40932 }
40933 {
40934 if (!wxPyCheckForApp()) SWIG_fail;
40935 PyThreadState* __tstate = wxPyBeginAllowThreads();
40936 result = (wxMenuBar *)new wxMenuBar(arg1);
40937 wxPyEndAllowThreads(__tstate);
40938 if (PyErr_Occurred()) SWIG_fail;
40939 }
40940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40941 return resultobj;
40942 fail:
40943 return NULL;
40944 }
40945
40946
40947 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40948 PyObject *resultobj = 0;
40949 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40950 wxMenu *arg2 = (wxMenu *) 0 ;
40951 wxString *arg3 = 0 ;
40952 bool result;
40953 void *argp1 = 0 ;
40954 int res1 = 0 ;
40955 void *argp2 = 0 ;
40956 int res2 = 0 ;
40957 bool temp3 = false ;
40958 PyObject * obj0 = 0 ;
40959 PyObject * obj1 = 0 ;
40960 PyObject * obj2 = 0 ;
40961 char * kwnames[] = {
40962 (char *) "self",(char *) "menu",(char *) "title", NULL
40963 };
40964
40965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40967 if (!SWIG_IsOK(res1)) {
40968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40969 }
40970 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40971 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40972 if (!SWIG_IsOK(res2)) {
40973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40974 }
40975 arg2 = reinterpret_cast< wxMenu * >(argp2);
40976 {
40977 arg3 = wxString_in_helper(obj2);
40978 if (arg3 == NULL) SWIG_fail;
40979 temp3 = true;
40980 }
40981 {
40982 PyThreadState* __tstate = wxPyBeginAllowThreads();
40983 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40984 wxPyEndAllowThreads(__tstate);
40985 if (PyErr_Occurred()) SWIG_fail;
40986 }
40987 {
40988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40989 }
40990 {
40991 if (temp3)
40992 delete arg3;
40993 }
40994 return resultobj;
40995 fail:
40996 {
40997 if (temp3)
40998 delete arg3;
40999 }
41000 return NULL;
41001 }
41002
41003
41004 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41005 PyObject *resultobj = 0;
41006 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41007 size_t arg2 ;
41008 wxMenu *arg3 = (wxMenu *) 0 ;
41009 wxString *arg4 = 0 ;
41010 bool result;
41011 void *argp1 = 0 ;
41012 int res1 = 0 ;
41013 size_t val2 ;
41014 int ecode2 = 0 ;
41015 void *argp3 = 0 ;
41016 int res3 = 0 ;
41017 bool temp4 = false ;
41018 PyObject * obj0 = 0 ;
41019 PyObject * obj1 = 0 ;
41020 PyObject * obj2 = 0 ;
41021 PyObject * obj3 = 0 ;
41022 char * kwnames[] = {
41023 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41024 };
41025
41026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41028 if (!SWIG_IsOK(res1)) {
41029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41030 }
41031 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41032 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41033 if (!SWIG_IsOK(ecode2)) {
41034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41035 }
41036 arg2 = static_cast< size_t >(val2);
41037 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41038 if (!SWIG_IsOK(res3)) {
41039 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41040 }
41041 arg3 = reinterpret_cast< wxMenu * >(argp3);
41042 {
41043 arg4 = wxString_in_helper(obj3);
41044 if (arg4 == NULL) SWIG_fail;
41045 temp4 = true;
41046 }
41047 {
41048 PyThreadState* __tstate = wxPyBeginAllowThreads();
41049 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41050 wxPyEndAllowThreads(__tstate);
41051 if (PyErr_Occurred()) SWIG_fail;
41052 }
41053 {
41054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41055 }
41056 {
41057 if (temp4)
41058 delete arg4;
41059 }
41060 return resultobj;
41061 fail:
41062 {
41063 if (temp4)
41064 delete arg4;
41065 }
41066 return NULL;
41067 }
41068
41069
41070 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41071 PyObject *resultobj = 0;
41072 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41073 size_t result;
41074 void *argp1 = 0 ;
41075 int res1 = 0 ;
41076 PyObject *swig_obj[1] ;
41077
41078 if (!args) SWIG_fail;
41079 swig_obj[0] = args;
41080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41081 if (!SWIG_IsOK(res1)) {
41082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41083 }
41084 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41085 {
41086 PyThreadState* __tstate = wxPyBeginAllowThreads();
41087 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41088 wxPyEndAllowThreads(__tstate);
41089 if (PyErr_Occurred()) SWIG_fail;
41090 }
41091 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41092 return resultobj;
41093 fail:
41094 return NULL;
41095 }
41096
41097
41098 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41099 PyObject *resultobj = 0;
41100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41101 size_t arg2 ;
41102 wxMenu *result = 0 ;
41103 void *argp1 = 0 ;
41104 int res1 = 0 ;
41105 size_t val2 ;
41106 int ecode2 = 0 ;
41107 PyObject * obj0 = 0 ;
41108 PyObject * obj1 = 0 ;
41109 char * kwnames[] = {
41110 (char *) "self",(char *) "pos", NULL
41111 };
41112
41113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41115 if (!SWIG_IsOK(res1)) {
41116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41117 }
41118 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41119 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41120 if (!SWIG_IsOK(ecode2)) {
41121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41122 }
41123 arg2 = static_cast< size_t >(val2);
41124 {
41125 PyThreadState* __tstate = wxPyBeginAllowThreads();
41126 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41127 wxPyEndAllowThreads(__tstate);
41128 if (PyErr_Occurred()) SWIG_fail;
41129 }
41130 {
41131 resultobj = wxPyMake_wxObject(result, 0);
41132 }
41133 return resultobj;
41134 fail:
41135 return NULL;
41136 }
41137
41138
41139 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41140 PyObject *resultobj = 0;
41141 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41142 size_t arg2 ;
41143 wxMenu *arg3 = (wxMenu *) 0 ;
41144 wxString *arg4 = 0 ;
41145 wxMenu *result = 0 ;
41146 void *argp1 = 0 ;
41147 int res1 = 0 ;
41148 size_t val2 ;
41149 int ecode2 = 0 ;
41150 void *argp3 = 0 ;
41151 int res3 = 0 ;
41152 bool temp4 = false ;
41153 PyObject * obj0 = 0 ;
41154 PyObject * obj1 = 0 ;
41155 PyObject * obj2 = 0 ;
41156 PyObject * obj3 = 0 ;
41157 char * kwnames[] = {
41158 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41159 };
41160
41161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41163 if (!SWIG_IsOK(res1)) {
41164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41165 }
41166 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41167 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41168 if (!SWIG_IsOK(ecode2)) {
41169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41170 }
41171 arg2 = static_cast< size_t >(val2);
41172 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41173 if (!SWIG_IsOK(res3)) {
41174 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41175 }
41176 arg3 = reinterpret_cast< wxMenu * >(argp3);
41177 {
41178 arg4 = wxString_in_helper(obj3);
41179 if (arg4 == NULL) SWIG_fail;
41180 temp4 = true;
41181 }
41182 {
41183 PyThreadState* __tstate = wxPyBeginAllowThreads();
41184 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41185 wxPyEndAllowThreads(__tstate);
41186 if (PyErr_Occurred()) SWIG_fail;
41187 }
41188 {
41189 resultobj = wxPyMake_wxObject(result, 0);
41190 }
41191 {
41192 if (temp4)
41193 delete arg4;
41194 }
41195 return resultobj;
41196 fail:
41197 {
41198 if (temp4)
41199 delete arg4;
41200 }
41201 return NULL;
41202 }
41203
41204
41205 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41206 PyObject *resultobj = 0;
41207 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41208 size_t arg2 ;
41209 wxMenu *result = 0 ;
41210 void *argp1 = 0 ;
41211 int res1 = 0 ;
41212 size_t val2 ;
41213 int ecode2 = 0 ;
41214 PyObject * obj0 = 0 ;
41215 PyObject * obj1 = 0 ;
41216 char * kwnames[] = {
41217 (char *) "self",(char *) "pos", NULL
41218 };
41219
41220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41222 if (!SWIG_IsOK(res1)) {
41223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41224 }
41225 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41226 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41227 if (!SWIG_IsOK(ecode2)) {
41228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41229 }
41230 arg2 = static_cast< size_t >(val2);
41231 {
41232 PyThreadState* __tstate = wxPyBeginAllowThreads();
41233 result = (wxMenu *)(arg1)->Remove(arg2);
41234 wxPyEndAllowThreads(__tstate);
41235 if (PyErr_Occurred()) SWIG_fail;
41236 }
41237 {
41238 resultobj = wxPyMake_wxObject(result, 0);
41239 }
41240 return resultobj;
41241 fail:
41242 return NULL;
41243 }
41244
41245
41246 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41247 PyObject *resultobj = 0;
41248 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41249 size_t arg2 ;
41250 bool arg3 ;
41251 void *argp1 = 0 ;
41252 int res1 = 0 ;
41253 size_t val2 ;
41254 int ecode2 = 0 ;
41255 bool val3 ;
41256 int ecode3 = 0 ;
41257 PyObject * obj0 = 0 ;
41258 PyObject * obj1 = 0 ;
41259 PyObject * obj2 = 0 ;
41260 char * kwnames[] = {
41261 (char *) "self",(char *) "pos",(char *) "enable", NULL
41262 };
41263
41264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41266 if (!SWIG_IsOK(res1)) {
41267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41268 }
41269 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41270 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41271 if (!SWIG_IsOK(ecode2)) {
41272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41273 }
41274 arg2 = static_cast< size_t >(val2);
41275 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41276 if (!SWIG_IsOK(ecode3)) {
41277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41278 }
41279 arg3 = static_cast< bool >(val3);
41280 {
41281 PyThreadState* __tstate = wxPyBeginAllowThreads();
41282 (arg1)->EnableTop(arg2,arg3);
41283 wxPyEndAllowThreads(__tstate);
41284 if (PyErr_Occurred()) SWIG_fail;
41285 }
41286 resultobj = SWIG_Py_Void();
41287 return resultobj;
41288 fail:
41289 return NULL;
41290 }
41291
41292
41293 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41294 PyObject *resultobj = 0;
41295 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41296 size_t arg2 ;
41297 bool result;
41298 void *argp1 = 0 ;
41299 int res1 = 0 ;
41300 size_t val2 ;
41301 int ecode2 = 0 ;
41302 PyObject * obj0 = 0 ;
41303 PyObject * obj1 = 0 ;
41304 char * kwnames[] = {
41305 (char *) "self",(char *) "pos", NULL
41306 };
41307
41308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41310 if (!SWIG_IsOK(res1)) {
41311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41312 }
41313 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41314 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41315 if (!SWIG_IsOK(ecode2)) {
41316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41317 }
41318 arg2 = static_cast< size_t >(val2);
41319 {
41320 PyThreadState* __tstate = wxPyBeginAllowThreads();
41321 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41322 wxPyEndAllowThreads(__tstate);
41323 if (PyErr_Occurred()) SWIG_fail;
41324 }
41325 {
41326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41327 }
41328 return resultobj;
41329 fail:
41330 return NULL;
41331 }
41332
41333
41334 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41335 PyObject *resultobj = 0;
41336 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41337 size_t arg2 ;
41338 wxString *arg3 = 0 ;
41339 void *argp1 = 0 ;
41340 int res1 = 0 ;
41341 size_t val2 ;
41342 int ecode2 = 0 ;
41343 bool temp3 = false ;
41344 PyObject * obj0 = 0 ;
41345 PyObject * obj1 = 0 ;
41346 PyObject * obj2 = 0 ;
41347 char * kwnames[] = {
41348 (char *) "self",(char *) "pos",(char *) "label", NULL
41349 };
41350
41351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41353 if (!SWIG_IsOK(res1)) {
41354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41355 }
41356 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41357 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41358 if (!SWIG_IsOK(ecode2)) {
41359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41360 }
41361 arg2 = static_cast< size_t >(val2);
41362 {
41363 arg3 = wxString_in_helper(obj2);
41364 if (arg3 == NULL) SWIG_fail;
41365 temp3 = true;
41366 }
41367 {
41368 PyThreadState* __tstate = wxPyBeginAllowThreads();
41369 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41370 wxPyEndAllowThreads(__tstate);
41371 if (PyErr_Occurred()) SWIG_fail;
41372 }
41373 resultobj = SWIG_Py_Void();
41374 {
41375 if (temp3)
41376 delete arg3;
41377 }
41378 return resultobj;
41379 fail:
41380 {
41381 if (temp3)
41382 delete arg3;
41383 }
41384 return NULL;
41385 }
41386
41387
41388 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41389 PyObject *resultobj = 0;
41390 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41391 size_t arg2 ;
41392 wxString result;
41393 void *argp1 = 0 ;
41394 int res1 = 0 ;
41395 size_t val2 ;
41396 int ecode2 = 0 ;
41397 PyObject * obj0 = 0 ;
41398 PyObject * obj1 = 0 ;
41399 char * kwnames[] = {
41400 (char *) "self",(char *) "pos", NULL
41401 };
41402
41403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41405 if (!SWIG_IsOK(res1)) {
41406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41407 }
41408 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41409 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41410 if (!SWIG_IsOK(ecode2)) {
41411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41412 }
41413 arg2 = static_cast< size_t >(val2);
41414 {
41415 PyThreadState* __tstate = wxPyBeginAllowThreads();
41416 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41417 wxPyEndAllowThreads(__tstate);
41418 if (PyErr_Occurred()) SWIG_fail;
41419 }
41420 {
41421 #if wxUSE_UNICODE
41422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41423 #else
41424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41425 #endif
41426 }
41427 return resultobj;
41428 fail:
41429 return NULL;
41430 }
41431
41432
41433 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41434 PyObject *resultobj = 0;
41435 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41436 wxString *arg2 = 0 ;
41437 wxString *arg3 = 0 ;
41438 int result;
41439 void *argp1 = 0 ;
41440 int res1 = 0 ;
41441 bool temp2 = false ;
41442 bool temp3 = false ;
41443 PyObject * obj0 = 0 ;
41444 PyObject * obj1 = 0 ;
41445 PyObject * obj2 = 0 ;
41446 char * kwnames[] = {
41447 (char *) "self",(char *) "menu",(char *) "item", NULL
41448 };
41449
41450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41452 if (!SWIG_IsOK(res1)) {
41453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41454 }
41455 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41456 {
41457 arg2 = wxString_in_helper(obj1);
41458 if (arg2 == NULL) SWIG_fail;
41459 temp2 = true;
41460 }
41461 {
41462 arg3 = wxString_in_helper(obj2);
41463 if (arg3 == NULL) SWIG_fail;
41464 temp3 = true;
41465 }
41466 {
41467 PyThreadState* __tstate = wxPyBeginAllowThreads();
41468 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41469 wxPyEndAllowThreads(__tstate);
41470 if (PyErr_Occurred()) SWIG_fail;
41471 }
41472 resultobj = SWIG_From_int(static_cast< int >(result));
41473 {
41474 if (temp2)
41475 delete arg2;
41476 }
41477 {
41478 if (temp3)
41479 delete arg3;
41480 }
41481 return resultobj;
41482 fail:
41483 {
41484 if (temp2)
41485 delete arg2;
41486 }
41487 {
41488 if (temp3)
41489 delete arg3;
41490 }
41491 return NULL;
41492 }
41493
41494
41495 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41496 PyObject *resultobj = 0;
41497 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41498 int arg2 ;
41499 wxMenuItem *result = 0 ;
41500 void *argp1 = 0 ;
41501 int res1 = 0 ;
41502 int val2 ;
41503 int ecode2 = 0 ;
41504 PyObject * obj0 = 0 ;
41505 PyObject * obj1 = 0 ;
41506 char * kwnames[] = {
41507 (char *) "self",(char *) "id", NULL
41508 };
41509
41510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41512 if (!SWIG_IsOK(res1)) {
41513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41514 }
41515 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41516 ecode2 = SWIG_AsVal_int(obj1, &val2);
41517 if (!SWIG_IsOK(ecode2)) {
41518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41519 }
41520 arg2 = static_cast< int >(val2);
41521 {
41522 PyThreadState* __tstate = wxPyBeginAllowThreads();
41523 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41524 wxPyEndAllowThreads(__tstate);
41525 if (PyErr_Occurred()) SWIG_fail;
41526 }
41527 {
41528 resultobj = wxPyMake_wxObject(result, (bool)0);
41529 }
41530 return resultobj;
41531 fail:
41532 return NULL;
41533 }
41534
41535
41536 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41537 PyObject *resultobj = 0;
41538 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41539 wxString *arg2 = 0 ;
41540 int result;
41541 void *argp1 = 0 ;
41542 int res1 = 0 ;
41543 bool temp2 = false ;
41544 PyObject * obj0 = 0 ;
41545 PyObject * obj1 = 0 ;
41546 char * kwnames[] = {
41547 (char *) "self",(char *) "title", NULL
41548 };
41549
41550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41552 if (!SWIG_IsOK(res1)) {
41553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41554 }
41555 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41556 {
41557 arg2 = wxString_in_helper(obj1);
41558 if (arg2 == NULL) SWIG_fail;
41559 temp2 = true;
41560 }
41561 {
41562 PyThreadState* __tstate = wxPyBeginAllowThreads();
41563 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41564 wxPyEndAllowThreads(__tstate);
41565 if (PyErr_Occurred()) SWIG_fail;
41566 }
41567 resultobj = SWIG_From_int(static_cast< int >(result));
41568 {
41569 if (temp2)
41570 delete arg2;
41571 }
41572 return resultobj;
41573 fail:
41574 {
41575 if (temp2)
41576 delete arg2;
41577 }
41578 return NULL;
41579 }
41580
41581
41582 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41583 PyObject *resultobj = 0;
41584 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41585 int arg2 ;
41586 bool arg3 ;
41587 void *argp1 = 0 ;
41588 int res1 = 0 ;
41589 int val2 ;
41590 int ecode2 = 0 ;
41591 bool val3 ;
41592 int ecode3 = 0 ;
41593 PyObject * obj0 = 0 ;
41594 PyObject * obj1 = 0 ;
41595 PyObject * obj2 = 0 ;
41596 char * kwnames[] = {
41597 (char *) "self",(char *) "id",(char *) "enable", NULL
41598 };
41599
41600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41602 if (!SWIG_IsOK(res1)) {
41603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41604 }
41605 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41606 ecode2 = SWIG_AsVal_int(obj1, &val2);
41607 if (!SWIG_IsOK(ecode2)) {
41608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41609 }
41610 arg2 = static_cast< int >(val2);
41611 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41612 if (!SWIG_IsOK(ecode3)) {
41613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41614 }
41615 arg3 = static_cast< bool >(val3);
41616 {
41617 PyThreadState* __tstate = wxPyBeginAllowThreads();
41618 (arg1)->Enable(arg2,arg3);
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 resultobj = SWIG_Py_Void();
41623 return resultobj;
41624 fail:
41625 return NULL;
41626 }
41627
41628
41629 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41630 PyObject *resultobj = 0;
41631 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41632 int arg2 ;
41633 bool arg3 ;
41634 void *argp1 = 0 ;
41635 int res1 = 0 ;
41636 int val2 ;
41637 int ecode2 = 0 ;
41638 bool val3 ;
41639 int ecode3 = 0 ;
41640 PyObject * obj0 = 0 ;
41641 PyObject * obj1 = 0 ;
41642 PyObject * obj2 = 0 ;
41643 char * kwnames[] = {
41644 (char *) "self",(char *) "id",(char *) "check", NULL
41645 };
41646
41647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41649 if (!SWIG_IsOK(res1)) {
41650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41651 }
41652 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41653 ecode2 = SWIG_AsVal_int(obj1, &val2);
41654 if (!SWIG_IsOK(ecode2)) {
41655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41656 }
41657 arg2 = static_cast< int >(val2);
41658 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41659 if (!SWIG_IsOK(ecode3)) {
41660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41661 }
41662 arg3 = static_cast< bool >(val3);
41663 {
41664 PyThreadState* __tstate = wxPyBeginAllowThreads();
41665 (arg1)->Check(arg2,arg3);
41666 wxPyEndAllowThreads(__tstate);
41667 if (PyErr_Occurred()) SWIG_fail;
41668 }
41669 resultobj = SWIG_Py_Void();
41670 return resultobj;
41671 fail:
41672 return NULL;
41673 }
41674
41675
41676 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41677 PyObject *resultobj = 0;
41678 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41679 int arg2 ;
41680 bool result;
41681 void *argp1 = 0 ;
41682 int res1 = 0 ;
41683 int val2 ;
41684 int ecode2 = 0 ;
41685 PyObject * obj0 = 0 ;
41686 PyObject * obj1 = 0 ;
41687 char * kwnames[] = {
41688 (char *) "self",(char *) "id", NULL
41689 };
41690
41691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41693 if (!SWIG_IsOK(res1)) {
41694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41695 }
41696 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41697 ecode2 = SWIG_AsVal_int(obj1, &val2);
41698 if (!SWIG_IsOK(ecode2)) {
41699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41700 }
41701 arg2 = static_cast< int >(val2);
41702 {
41703 PyThreadState* __tstate = wxPyBeginAllowThreads();
41704 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41705 wxPyEndAllowThreads(__tstate);
41706 if (PyErr_Occurred()) SWIG_fail;
41707 }
41708 {
41709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41710 }
41711 return resultobj;
41712 fail:
41713 return NULL;
41714 }
41715
41716
41717 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41718 PyObject *resultobj = 0;
41719 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41720 int arg2 ;
41721 bool result;
41722 void *argp1 = 0 ;
41723 int res1 = 0 ;
41724 int val2 ;
41725 int ecode2 = 0 ;
41726 PyObject * obj0 = 0 ;
41727 PyObject * obj1 = 0 ;
41728 char * kwnames[] = {
41729 (char *) "self",(char *) "id", NULL
41730 };
41731
41732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41734 if (!SWIG_IsOK(res1)) {
41735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41736 }
41737 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41738 ecode2 = SWIG_AsVal_int(obj1, &val2);
41739 if (!SWIG_IsOK(ecode2)) {
41740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41741 }
41742 arg2 = static_cast< int >(val2);
41743 {
41744 PyThreadState* __tstate = wxPyBeginAllowThreads();
41745 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41746 wxPyEndAllowThreads(__tstate);
41747 if (PyErr_Occurred()) SWIG_fail;
41748 }
41749 {
41750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41751 }
41752 return resultobj;
41753 fail:
41754 return NULL;
41755 }
41756
41757
41758 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41759 PyObject *resultobj = 0;
41760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41761 int arg2 ;
41762 wxString *arg3 = 0 ;
41763 void *argp1 = 0 ;
41764 int res1 = 0 ;
41765 int val2 ;
41766 int ecode2 = 0 ;
41767 bool temp3 = false ;
41768 PyObject * obj0 = 0 ;
41769 PyObject * obj1 = 0 ;
41770 PyObject * obj2 = 0 ;
41771 char * kwnames[] = {
41772 (char *) "self",(char *) "id",(char *) "label", NULL
41773 };
41774
41775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41777 if (!SWIG_IsOK(res1)) {
41778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41779 }
41780 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41781 ecode2 = SWIG_AsVal_int(obj1, &val2);
41782 if (!SWIG_IsOK(ecode2)) {
41783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41784 }
41785 arg2 = static_cast< int >(val2);
41786 {
41787 arg3 = wxString_in_helper(obj2);
41788 if (arg3 == NULL) SWIG_fail;
41789 temp3 = true;
41790 }
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41794 wxPyEndAllowThreads(__tstate);
41795 if (PyErr_Occurred()) SWIG_fail;
41796 }
41797 resultobj = SWIG_Py_Void();
41798 {
41799 if (temp3)
41800 delete arg3;
41801 }
41802 return resultobj;
41803 fail:
41804 {
41805 if (temp3)
41806 delete arg3;
41807 }
41808 return NULL;
41809 }
41810
41811
41812 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41813 PyObject *resultobj = 0;
41814 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41815 int arg2 ;
41816 wxString result;
41817 void *argp1 = 0 ;
41818 int res1 = 0 ;
41819 int val2 ;
41820 int ecode2 = 0 ;
41821 PyObject * obj0 = 0 ;
41822 PyObject * obj1 = 0 ;
41823 char * kwnames[] = {
41824 (char *) "self",(char *) "id", NULL
41825 };
41826
41827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41829 if (!SWIG_IsOK(res1)) {
41830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41831 }
41832 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41833 ecode2 = SWIG_AsVal_int(obj1, &val2);
41834 if (!SWIG_IsOK(ecode2)) {
41835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41836 }
41837 arg2 = static_cast< int >(val2);
41838 {
41839 PyThreadState* __tstate = wxPyBeginAllowThreads();
41840 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41841 wxPyEndAllowThreads(__tstate);
41842 if (PyErr_Occurred()) SWIG_fail;
41843 }
41844 {
41845 #if wxUSE_UNICODE
41846 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41847 #else
41848 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41849 #endif
41850 }
41851 return resultobj;
41852 fail:
41853 return NULL;
41854 }
41855
41856
41857 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41858 PyObject *resultobj = 0;
41859 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41860 int arg2 ;
41861 wxString *arg3 = 0 ;
41862 void *argp1 = 0 ;
41863 int res1 = 0 ;
41864 int val2 ;
41865 int ecode2 = 0 ;
41866 bool temp3 = false ;
41867 PyObject * obj0 = 0 ;
41868 PyObject * obj1 = 0 ;
41869 PyObject * obj2 = 0 ;
41870 char * kwnames[] = {
41871 (char *) "self",(char *) "id",(char *) "helpString", NULL
41872 };
41873
41874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41876 if (!SWIG_IsOK(res1)) {
41877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41878 }
41879 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41880 ecode2 = SWIG_AsVal_int(obj1, &val2);
41881 if (!SWIG_IsOK(ecode2)) {
41882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41883 }
41884 arg2 = static_cast< int >(val2);
41885 {
41886 arg3 = wxString_in_helper(obj2);
41887 if (arg3 == NULL) SWIG_fail;
41888 temp3 = true;
41889 }
41890 {
41891 PyThreadState* __tstate = wxPyBeginAllowThreads();
41892 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41893 wxPyEndAllowThreads(__tstate);
41894 if (PyErr_Occurred()) SWIG_fail;
41895 }
41896 resultobj = SWIG_Py_Void();
41897 {
41898 if (temp3)
41899 delete arg3;
41900 }
41901 return resultobj;
41902 fail:
41903 {
41904 if (temp3)
41905 delete arg3;
41906 }
41907 return NULL;
41908 }
41909
41910
41911 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41912 PyObject *resultobj = 0;
41913 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41914 int arg2 ;
41915 wxString result;
41916 void *argp1 = 0 ;
41917 int res1 = 0 ;
41918 int val2 ;
41919 int ecode2 = 0 ;
41920 PyObject * obj0 = 0 ;
41921 PyObject * obj1 = 0 ;
41922 char * kwnames[] = {
41923 (char *) "self",(char *) "id", NULL
41924 };
41925
41926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41928 if (!SWIG_IsOK(res1)) {
41929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41930 }
41931 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41932 ecode2 = SWIG_AsVal_int(obj1, &val2);
41933 if (!SWIG_IsOK(ecode2)) {
41934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41935 }
41936 arg2 = static_cast< int >(val2);
41937 {
41938 PyThreadState* __tstate = wxPyBeginAllowThreads();
41939 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41940 wxPyEndAllowThreads(__tstate);
41941 if (PyErr_Occurred()) SWIG_fail;
41942 }
41943 {
41944 #if wxUSE_UNICODE
41945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41946 #else
41947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41948 #endif
41949 }
41950 return resultobj;
41951 fail:
41952 return NULL;
41953 }
41954
41955
41956 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41957 PyObject *resultobj = 0;
41958 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41959 wxFrame *result = 0 ;
41960 void *argp1 = 0 ;
41961 int res1 = 0 ;
41962 PyObject *swig_obj[1] ;
41963
41964 if (!args) SWIG_fail;
41965 swig_obj[0] = args;
41966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41967 if (!SWIG_IsOK(res1)) {
41968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41969 }
41970 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41971 {
41972 PyThreadState* __tstate = wxPyBeginAllowThreads();
41973 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41974 wxPyEndAllowThreads(__tstate);
41975 if (PyErr_Occurred()) SWIG_fail;
41976 }
41977 {
41978 resultobj = wxPyMake_wxObject(result, (bool)0);
41979 }
41980 return resultobj;
41981 fail:
41982 return NULL;
41983 }
41984
41985
41986 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41987 PyObject *resultobj = 0;
41988 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41989 bool result;
41990 void *argp1 = 0 ;
41991 int res1 = 0 ;
41992 PyObject *swig_obj[1] ;
41993
41994 if (!args) SWIG_fail;
41995 swig_obj[0] = args;
41996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41997 if (!SWIG_IsOK(res1)) {
41998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41999 }
42000 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42001 {
42002 PyThreadState* __tstate = wxPyBeginAllowThreads();
42003 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42004 wxPyEndAllowThreads(__tstate);
42005 if (PyErr_Occurred()) SWIG_fail;
42006 }
42007 {
42008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42009 }
42010 return resultobj;
42011 fail:
42012 return NULL;
42013 }
42014
42015
42016 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42017 PyObject *resultobj = 0;
42018 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42019 wxFrame *arg2 = (wxFrame *) 0 ;
42020 void *argp1 = 0 ;
42021 int res1 = 0 ;
42022 void *argp2 = 0 ;
42023 int res2 = 0 ;
42024 PyObject * obj0 = 0 ;
42025 PyObject * obj1 = 0 ;
42026 char * kwnames[] = {
42027 (char *) "self",(char *) "frame", NULL
42028 };
42029
42030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42032 if (!SWIG_IsOK(res1)) {
42033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42034 }
42035 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42037 if (!SWIG_IsOK(res2)) {
42038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42039 }
42040 arg2 = reinterpret_cast< wxFrame * >(argp2);
42041 {
42042 PyThreadState* __tstate = wxPyBeginAllowThreads();
42043 (arg1)->Attach(arg2);
42044 wxPyEndAllowThreads(__tstate);
42045 if (PyErr_Occurred()) SWIG_fail;
42046 }
42047 resultobj = SWIG_Py_Void();
42048 return resultobj;
42049 fail:
42050 return NULL;
42051 }
42052
42053
42054 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42055 PyObject *resultobj = 0;
42056 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42057 void *argp1 = 0 ;
42058 int res1 = 0 ;
42059 PyObject *swig_obj[1] ;
42060
42061 if (!args) SWIG_fail;
42062 swig_obj[0] = args;
42063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42064 if (!SWIG_IsOK(res1)) {
42065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42066 }
42067 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42068 {
42069 PyThreadState* __tstate = wxPyBeginAllowThreads();
42070 (arg1)->Detach();
42071 wxPyEndAllowThreads(__tstate);
42072 if (PyErr_Occurred()) SWIG_fail;
42073 }
42074 resultobj = SWIG_Py_Void();
42075 return resultobj;
42076 fail:
42077 return NULL;
42078 }
42079
42080
42081 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42082 PyObject *resultobj = 0;
42083 bool arg1 ;
42084 bool val1 ;
42085 int ecode1 = 0 ;
42086 PyObject * obj0 = 0 ;
42087 char * kwnames[] = {
42088 (char *) "enable", NULL
42089 };
42090
42091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42092 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42093 if (!SWIG_IsOK(ecode1)) {
42094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42095 }
42096 arg1 = static_cast< bool >(val1);
42097 {
42098 PyThreadState* __tstate = wxPyBeginAllowThreads();
42099 wxMenuBar_SetAutoWindowMenu(arg1);
42100 wxPyEndAllowThreads(__tstate);
42101 if (PyErr_Occurred()) SWIG_fail;
42102 }
42103 resultobj = SWIG_Py_Void();
42104 return resultobj;
42105 fail:
42106 return NULL;
42107 }
42108
42109
42110 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42111 PyObject *resultobj = 0;
42112 bool result;
42113
42114 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42115 {
42116 PyThreadState* __tstate = wxPyBeginAllowThreads();
42117 result = (bool)wxMenuBar_GetAutoWindowMenu();
42118 wxPyEndAllowThreads(__tstate);
42119 if (PyErr_Occurred()) SWIG_fail;
42120 }
42121 {
42122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42123 }
42124 return resultobj;
42125 fail:
42126 return NULL;
42127 }
42128
42129
42130 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42131 PyObject *obj;
42132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42133 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42134 return SWIG_Py_Void();
42135 }
42136
42137 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42138 return SWIG_Python_InitShadowInstance(args);
42139 }
42140
42141 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42142 PyObject *resultobj = 0;
42143 wxMenu *arg1 = (wxMenu *) NULL ;
42144 int arg2 = (int) wxID_ANY ;
42145 wxString const &arg3_defvalue = wxPyEmptyString ;
42146 wxString *arg3 = (wxString *) &arg3_defvalue ;
42147 wxString const &arg4_defvalue = wxPyEmptyString ;
42148 wxString *arg4 = (wxString *) &arg4_defvalue ;
42149 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42150 wxMenu *arg6 = (wxMenu *) NULL ;
42151 wxMenuItem *result = 0 ;
42152 void *argp1 = 0 ;
42153 int res1 = 0 ;
42154 int val2 ;
42155 int ecode2 = 0 ;
42156 bool temp3 = false ;
42157 bool temp4 = false ;
42158 int val5 ;
42159 int ecode5 = 0 ;
42160 void *argp6 = 0 ;
42161 int res6 = 0 ;
42162 PyObject * obj0 = 0 ;
42163 PyObject * obj1 = 0 ;
42164 PyObject * obj2 = 0 ;
42165 PyObject * obj3 = 0 ;
42166 PyObject * obj4 = 0 ;
42167 PyObject * obj5 = 0 ;
42168 char * kwnames[] = {
42169 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42170 };
42171
42172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42173 if (obj0) {
42174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42175 if (!SWIG_IsOK(res1)) {
42176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42177 }
42178 arg1 = reinterpret_cast< wxMenu * >(argp1);
42179 }
42180 if (obj1) {
42181 ecode2 = SWIG_AsVal_int(obj1, &val2);
42182 if (!SWIG_IsOK(ecode2)) {
42183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42184 }
42185 arg2 = static_cast< int >(val2);
42186 }
42187 if (obj2) {
42188 {
42189 arg3 = wxString_in_helper(obj2);
42190 if (arg3 == NULL) SWIG_fail;
42191 temp3 = true;
42192 }
42193 }
42194 if (obj3) {
42195 {
42196 arg4 = wxString_in_helper(obj3);
42197 if (arg4 == NULL) SWIG_fail;
42198 temp4 = true;
42199 }
42200 }
42201 if (obj4) {
42202 ecode5 = SWIG_AsVal_int(obj4, &val5);
42203 if (!SWIG_IsOK(ecode5)) {
42204 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42205 }
42206 arg5 = static_cast< wxItemKind >(val5);
42207 }
42208 if (obj5) {
42209 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42210 if (!SWIG_IsOK(res6)) {
42211 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42212 }
42213 arg6 = reinterpret_cast< wxMenu * >(argp6);
42214 }
42215 {
42216 PyThreadState* __tstate = wxPyBeginAllowThreads();
42217 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42218 wxPyEndAllowThreads(__tstate);
42219 if (PyErr_Occurred()) SWIG_fail;
42220 }
42221 {
42222 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42223 }
42224 {
42225 if (temp3)
42226 delete arg3;
42227 }
42228 {
42229 if (temp4)
42230 delete arg4;
42231 }
42232 return resultobj;
42233 fail:
42234 {
42235 if (temp3)
42236 delete arg3;
42237 }
42238 {
42239 if (temp4)
42240 delete arg4;
42241 }
42242 return NULL;
42243 }
42244
42245
42246 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42247 PyObject *resultobj = 0;
42248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42249 void *argp1 = 0 ;
42250 int res1 = 0 ;
42251 PyObject *swig_obj[1] ;
42252
42253 if (!args) SWIG_fail;
42254 swig_obj[0] = args;
42255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42256 if (!SWIG_IsOK(res1)) {
42257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42258 }
42259 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42260 {
42261 PyThreadState* __tstate = wxPyBeginAllowThreads();
42262 delete arg1;
42263
42264 wxPyEndAllowThreads(__tstate);
42265 if (PyErr_Occurred()) SWIG_fail;
42266 }
42267 resultobj = SWIG_Py_Void();
42268 return resultobj;
42269 fail:
42270 return NULL;
42271 }
42272
42273
42274 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42275 PyObject *resultobj = 0;
42276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42277 wxMenu *result = 0 ;
42278 void *argp1 = 0 ;
42279 int res1 = 0 ;
42280 PyObject *swig_obj[1] ;
42281
42282 if (!args) SWIG_fail;
42283 swig_obj[0] = args;
42284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42285 if (!SWIG_IsOK(res1)) {
42286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42287 }
42288 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42289 {
42290 PyThreadState* __tstate = wxPyBeginAllowThreads();
42291 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42292 wxPyEndAllowThreads(__tstate);
42293 if (PyErr_Occurred()) SWIG_fail;
42294 }
42295 {
42296 resultobj = wxPyMake_wxObject(result, 0);
42297 }
42298 return resultobj;
42299 fail:
42300 return NULL;
42301 }
42302
42303
42304 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42305 PyObject *resultobj = 0;
42306 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42307 wxMenu *arg2 = (wxMenu *) 0 ;
42308 void *argp1 = 0 ;
42309 int res1 = 0 ;
42310 void *argp2 = 0 ;
42311 int res2 = 0 ;
42312 PyObject * obj0 = 0 ;
42313 PyObject * obj1 = 0 ;
42314 char * kwnames[] = {
42315 (char *) "self",(char *) "menu", NULL
42316 };
42317
42318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42320 if (!SWIG_IsOK(res1)) {
42321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42322 }
42323 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42324 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42325 if (!SWIG_IsOK(res2)) {
42326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42327 }
42328 arg2 = reinterpret_cast< wxMenu * >(argp2);
42329 {
42330 PyThreadState* __tstate = wxPyBeginAllowThreads();
42331 (arg1)->SetMenu(arg2);
42332 wxPyEndAllowThreads(__tstate);
42333 if (PyErr_Occurred()) SWIG_fail;
42334 }
42335 resultobj = SWIG_Py_Void();
42336 return resultobj;
42337 fail:
42338 return NULL;
42339 }
42340
42341
42342 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42343 PyObject *resultobj = 0;
42344 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42345 int arg2 ;
42346 void *argp1 = 0 ;
42347 int res1 = 0 ;
42348 int val2 ;
42349 int ecode2 = 0 ;
42350 PyObject * obj0 = 0 ;
42351 PyObject * obj1 = 0 ;
42352 char * kwnames[] = {
42353 (char *) "self",(char *) "id", NULL
42354 };
42355
42356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42358 if (!SWIG_IsOK(res1)) {
42359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42360 }
42361 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42362 ecode2 = SWIG_AsVal_int(obj1, &val2);
42363 if (!SWIG_IsOK(ecode2)) {
42364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42365 }
42366 arg2 = static_cast< int >(val2);
42367 {
42368 PyThreadState* __tstate = wxPyBeginAllowThreads();
42369 (arg1)->SetId(arg2);
42370 wxPyEndAllowThreads(__tstate);
42371 if (PyErr_Occurred()) SWIG_fail;
42372 }
42373 resultobj = SWIG_Py_Void();
42374 return resultobj;
42375 fail:
42376 return NULL;
42377 }
42378
42379
42380 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42381 PyObject *resultobj = 0;
42382 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42383 int result;
42384 void *argp1 = 0 ;
42385 int res1 = 0 ;
42386 PyObject *swig_obj[1] ;
42387
42388 if (!args) SWIG_fail;
42389 swig_obj[0] = args;
42390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42391 if (!SWIG_IsOK(res1)) {
42392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42393 }
42394 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42395 {
42396 PyThreadState* __tstate = wxPyBeginAllowThreads();
42397 result = (int)((wxMenuItem const *)arg1)->GetId();
42398 wxPyEndAllowThreads(__tstate);
42399 if (PyErr_Occurred()) SWIG_fail;
42400 }
42401 resultobj = SWIG_From_int(static_cast< int >(result));
42402 return resultobj;
42403 fail:
42404 return NULL;
42405 }
42406
42407
42408 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42409 PyObject *resultobj = 0;
42410 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42411 bool result;
42412 void *argp1 = 0 ;
42413 int res1 = 0 ;
42414 PyObject *swig_obj[1] ;
42415
42416 if (!args) SWIG_fail;
42417 swig_obj[0] = args;
42418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42419 if (!SWIG_IsOK(res1)) {
42420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42421 }
42422 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42423 {
42424 PyThreadState* __tstate = wxPyBeginAllowThreads();
42425 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42426 wxPyEndAllowThreads(__tstate);
42427 if (PyErr_Occurred()) SWIG_fail;
42428 }
42429 {
42430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42431 }
42432 return resultobj;
42433 fail:
42434 return NULL;
42435 }
42436
42437
42438 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42439 PyObject *resultobj = 0;
42440 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42441 wxString *arg2 = 0 ;
42442 void *argp1 = 0 ;
42443 int res1 = 0 ;
42444 bool temp2 = false ;
42445 PyObject * obj0 = 0 ;
42446 PyObject * obj1 = 0 ;
42447 char * kwnames[] = {
42448 (char *) "self",(char *) "str", NULL
42449 };
42450
42451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42453 if (!SWIG_IsOK(res1)) {
42454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42455 }
42456 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42457 {
42458 arg2 = wxString_in_helper(obj1);
42459 if (arg2 == NULL) SWIG_fail;
42460 temp2 = true;
42461 }
42462 {
42463 PyThreadState* __tstate = wxPyBeginAllowThreads();
42464 (arg1)->SetText((wxString const &)*arg2);
42465 wxPyEndAllowThreads(__tstate);
42466 if (PyErr_Occurred()) SWIG_fail;
42467 }
42468 resultobj = SWIG_Py_Void();
42469 {
42470 if (temp2)
42471 delete arg2;
42472 }
42473 return resultobj;
42474 fail:
42475 {
42476 if (temp2)
42477 delete arg2;
42478 }
42479 return NULL;
42480 }
42481
42482
42483 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42484 PyObject *resultobj = 0;
42485 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42486 wxString result;
42487 void *argp1 = 0 ;
42488 int res1 = 0 ;
42489 PyObject *swig_obj[1] ;
42490
42491 if (!args) SWIG_fail;
42492 swig_obj[0] = args;
42493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42494 if (!SWIG_IsOK(res1)) {
42495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42496 }
42497 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42498 {
42499 PyThreadState* __tstate = wxPyBeginAllowThreads();
42500 result = ((wxMenuItem const *)arg1)->GetLabel();
42501 wxPyEndAllowThreads(__tstate);
42502 if (PyErr_Occurred()) SWIG_fail;
42503 }
42504 {
42505 #if wxUSE_UNICODE
42506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42507 #else
42508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42509 #endif
42510 }
42511 return resultobj;
42512 fail:
42513 return NULL;
42514 }
42515
42516
42517 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42518 PyObject *resultobj = 0;
42519 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42520 wxString *result = 0 ;
42521 void *argp1 = 0 ;
42522 int res1 = 0 ;
42523 PyObject *swig_obj[1] ;
42524
42525 if (!args) SWIG_fail;
42526 swig_obj[0] = args;
42527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42528 if (!SWIG_IsOK(res1)) {
42529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42530 }
42531 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42532 {
42533 PyThreadState* __tstate = wxPyBeginAllowThreads();
42534 {
42535 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42536 result = (wxString *) &_result_ref;
42537 }
42538 wxPyEndAllowThreads(__tstate);
42539 if (PyErr_Occurred()) SWIG_fail;
42540 }
42541 {
42542 #if wxUSE_UNICODE
42543 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42544 #else
42545 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42546 #endif
42547 }
42548 return resultobj;
42549 fail:
42550 return NULL;
42551 }
42552
42553
42554 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42555 PyObject *resultobj = 0;
42556 wxString *arg1 = 0 ;
42557 wxString result;
42558 bool temp1 = false ;
42559 PyObject * obj0 = 0 ;
42560 char * kwnames[] = {
42561 (char *) "text", NULL
42562 };
42563
42564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42565 {
42566 arg1 = wxString_in_helper(obj0);
42567 if (arg1 == NULL) SWIG_fail;
42568 temp1 = true;
42569 }
42570 {
42571 PyThreadState* __tstate = wxPyBeginAllowThreads();
42572 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42573 wxPyEndAllowThreads(__tstate);
42574 if (PyErr_Occurred()) SWIG_fail;
42575 }
42576 {
42577 #if wxUSE_UNICODE
42578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42579 #else
42580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42581 #endif
42582 }
42583 {
42584 if (temp1)
42585 delete arg1;
42586 }
42587 return resultobj;
42588 fail:
42589 {
42590 if (temp1)
42591 delete arg1;
42592 }
42593 return NULL;
42594 }
42595
42596
42597 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42598 PyObject *resultobj = 0;
42599 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42600 wxItemKind result;
42601 void *argp1 = 0 ;
42602 int res1 = 0 ;
42603 PyObject *swig_obj[1] ;
42604
42605 if (!args) SWIG_fail;
42606 swig_obj[0] = args;
42607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42608 if (!SWIG_IsOK(res1)) {
42609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42610 }
42611 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42612 {
42613 PyThreadState* __tstate = wxPyBeginAllowThreads();
42614 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42615 wxPyEndAllowThreads(__tstate);
42616 if (PyErr_Occurred()) SWIG_fail;
42617 }
42618 resultobj = SWIG_From_int(static_cast< int >(result));
42619 return resultobj;
42620 fail:
42621 return NULL;
42622 }
42623
42624
42625 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42626 PyObject *resultobj = 0;
42627 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42628 wxItemKind arg2 ;
42629 void *argp1 = 0 ;
42630 int res1 = 0 ;
42631 int val2 ;
42632 int ecode2 = 0 ;
42633 PyObject * obj0 = 0 ;
42634 PyObject * obj1 = 0 ;
42635 char * kwnames[] = {
42636 (char *) "self",(char *) "kind", NULL
42637 };
42638
42639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42641 if (!SWIG_IsOK(res1)) {
42642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42643 }
42644 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42645 ecode2 = SWIG_AsVal_int(obj1, &val2);
42646 if (!SWIG_IsOK(ecode2)) {
42647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42648 }
42649 arg2 = static_cast< wxItemKind >(val2);
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 (arg1)->SetKind(arg2);
42653 wxPyEndAllowThreads(__tstate);
42654 if (PyErr_Occurred()) SWIG_fail;
42655 }
42656 resultobj = SWIG_Py_Void();
42657 return resultobj;
42658 fail:
42659 return NULL;
42660 }
42661
42662
42663 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42664 PyObject *resultobj = 0;
42665 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42666 bool arg2 ;
42667 void *argp1 = 0 ;
42668 int res1 = 0 ;
42669 bool val2 ;
42670 int ecode2 = 0 ;
42671 PyObject * obj0 = 0 ;
42672 PyObject * obj1 = 0 ;
42673 char * kwnames[] = {
42674 (char *) "self",(char *) "checkable", NULL
42675 };
42676
42677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42679 if (!SWIG_IsOK(res1)) {
42680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42681 }
42682 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42684 if (!SWIG_IsOK(ecode2)) {
42685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42686 }
42687 arg2 = static_cast< bool >(val2);
42688 {
42689 PyThreadState* __tstate = wxPyBeginAllowThreads();
42690 (arg1)->SetCheckable(arg2);
42691 wxPyEndAllowThreads(__tstate);
42692 if (PyErr_Occurred()) SWIG_fail;
42693 }
42694 resultobj = SWIG_Py_Void();
42695 return resultobj;
42696 fail:
42697 return NULL;
42698 }
42699
42700
42701 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42702 PyObject *resultobj = 0;
42703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42704 bool result;
42705 void *argp1 = 0 ;
42706 int res1 = 0 ;
42707 PyObject *swig_obj[1] ;
42708
42709 if (!args) SWIG_fail;
42710 swig_obj[0] = args;
42711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42712 if (!SWIG_IsOK(res1)) {
42713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42714 }
42715 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42716 {
42717 PyThreadState* __tstate = wxPyBeginAllowThreads();
42718 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42719 wxPyEndAllowThreads(__tstate);
42720 if (PyErr_Occurred()) SWIG_fail;
42721 }
42722 {
42723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42724 }
42725 return resultobj;
42726 fail:
42727 return NULL;
42728 }
42729
42730
42731 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42732 PyObject *resultobj = 0;
42733 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42734 bool result;
42735 void *argp1 = 0 ;
42736 int res1 = 0 ;
42737 PyObject *swig_obj[1] ;
42738
42739 if (!args) SWIG_fail;
42740 swig_obj[0] = args;
42741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42742 if (!SWIG_IsOK(res1)) {
42743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42744 }
42745 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42746 {
42747 PyThreadState* __tstate = wxPyBeginAllowThreads();
42748 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42749 wxPyEndAllowThreads(__tstate);
42750 if (PyErr_Occurred()) SWIG_fail;
42751 }
42752 {
42753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42754 }
42755 return resultobj;
42756 fail:
42757 return NULL;
42758 }
42759
42760
42761 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42762 PyObject *resultobj = 0;
42763 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42764 wxMenu *arg2 = (wxMenu *) 0 ;
42765 void *argp1 = 0 ;
42766 int res1 = 0 ;
42767 void *argp2 = 0 ;
42768 int res2 = 0 ;
42769 PyObject * obj0 = 0 ;
42770 PyObject * obj1 = 0 ;
42771 char * kwnames[] = {
42772 (char *) "self",(char *) "menu", NULL
42773 };
42774
42775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42777 if (!SWIG_IsOK(res1)) {
42778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42779 }
42780 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42781 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42782 if (!SWIG_IsOK(res2)) {
42783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42784 }
42785 arg2 = reinterpret_cast< wxMenu * >(argp2);
42786 {
42787 PyThreadState* __tstate = wxPyBeginAllowThreads();
42788 (arg1)->SetSubMenu(arg2);
42789 wxPyEndAllowThreads(__tstate);
42790 if (PyErr_Occurred()) SWIG_fail;
42791 }
42792 resultobj = SWIG_Py_Void();
42793 return resultobj;
42794 fail:
42795 return NULL;
42796 }
42797
42798
42799 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42800 PyObject *resultobj = 0;
42801 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42802 wxMenu *result = 0 ;
42803 void *argp1 = 0 ;
42804 int res1 = 0 ;
42805 PyObject *swig_obj[1] ;
42806
42807 if (!args) SWIG_fail;
42808 swig_obj[0] = args;
42809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42810 if (!SWIG_IsOK(res1)) {
42811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42812 }
42813 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42814 {
42815 PyThreadState* __tstate = wxPyBeginAllowThreads();
42816 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42817 wxPyEndAllowThreads(__tstate);
42818 if (PyErr_Occurred()) SWIG_fail;
42819 }
42820 {
42821 resultobj = wxPyMake_wxObject(result, 0);
42822 }
42823 return resultobj;
42824 fail:
42825 return NULL;
42826 }
42827
42828
42829 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42830 PyObject *resultobj = 0;
42831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42832 bool arg2 = (bool) true ;
42833 void *argp1 = 0 ;
42834 int res1 = 0 ;
42835 bool val2 ;
42836 int ecode2 = 0 ;
42837 PyObject * obj0 = 0 ;
42838 PyObject * obj1 = 0 ;
42839 char * kwnames[] = {
42840 (char *) "self",(char *) "enable", NULL
42841 };
42842
42843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42845 if (!SWIG_IsOK(res1)) {
42846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42847 }
42848 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42849 if (obj1) {
42850 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42851 if (!SWIG_IsOK(ecode2)) {
42852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42853 }
42854 arg2 = static_cast< bool >(val2);
42855 }
42856 {
42857 PyThreadState* __tstate = wxPyBeginAllowThreads();
42858 (arg1)->Enable(arg2);
42859 wxPyEndAllowThreads(__tstate);
42860 if (PyErr_Occurred()) SWIG_fail;
42861 }
42862 resultobj = SWIG_Py_Void();
42863 return resultobj;
42864 fail:
42865 return NULL;
42866 }
42867
42868
42869 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42870 PyObject *resultobj = 0;
42871 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42872 bool result;
42873 void *argp1 = 0 ;
42874 int res1 = 0 ;
42875 PyObject *swig_obj[1] ;
42876
42877 if (!args) SWIG_fail;
42878 swig_obj[0] = args;
42879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42880 if (!SWIG_IsOK(res1)) {
42881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42882 }
42883 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42884 {
42885 PyThreadState* __tstate = wxPyBeginAllowThreads();
42886 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42887 wxPyEndAllowThreads(__tstate);
42888 if (PyErr_Occurred()) SWIG_fail;
42889 }
42890 {
42891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42892 }
42893 return resultobj;
42894 fail:
42895 return NULL;
42896 }
42897
42898
42899 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42900 PyObject *resultobj = 0;
42901 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42902 bool arg2 = (bool) true ;
42903 void *argp1 = 0 ;
42904 int res1 = 0 ;
42905 bool val2 ;
42906 int ecode2 = 0 ;
42907 PyObject * obj0 = 0 ;
42908 PyObject * obj1 = 0 ;
42909 char * kwnames[] = {
42910 (char *) "self",(char *) "check", NULL
42911 };
42912
42913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42915 if (!SWIG_IsOK(res1)) {
42916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42917 }
42918 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42919 if (obj1) {
42920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42921 if (!SWIG_IsOK(ecode2)) {
42922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42923 }
42924 arg2 = static_cast< bool >(val2);
42925 }
42926 {
42927 PyThreadState* __tstate = wxPyBeginAllowThreads();
42928 (arg1)->Check(arg2);
42929 wxPyEndAllowThreads(__tstate);
42930 if (PyErr_Occurred()) SWIG_fail;
42931 }
42932 resultobj = SWIG_Py_Void();
42933 return resultobj;
42934 fail:
42935 return NULL;
42936 }
42937
42938
42939 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42940 PyObject *resultobj = 0;
42941 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42942 bool result;
42943 void *argp1 = 0 ;
42944 int res1 = 0 ;
42945 PyObject *swig_obj[1] ;
42946
42947 if (!args) SWIG_fail;
42948 swig_obj[0] = args;
42949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42950 if (!SWIG_IsOK(res1)) {
42951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42952 }
42953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42954 {
42955 PyThreadState* __tstate = wxPyBeginAllowThreads();
42956 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42957 wxPyEndAllowThreads(__tstate);
42958 if (PyErr_Occurred()) SWIG_fail;
42959 }
42960 {
42961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42962 }
42963 return resultobj;
42964 fail:
42965 return NULL;
42966 }
42967
42968
42969 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42970 PyObject *resultobj = 0;
42971 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42972 void *argp1 = 0 ;
42973 int res1 = 0 ;
42974 PyObject *swig_obj[1] ;
42975
42976 if (!args) SWIG_fail;
42977 swig_obj[0] = args;
42978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42979 if (!SWIG_IsOK(res1)) {
42980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42981 }
42982 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42983 {
42984 PyThreadState* __tstate = wxPyBeginAllowThreads();
42985 (arg1)->Toggle();
42986 wxPyEndAllowThreads(__tstate);
42987 if (PyErr_Occurred()) SWIG_fail;
42988 }
42989 resultobj = SWIG_Py_Void();
42990 return resultobj;
42991 fail:
42992 return NULL;
42993 }
42994
42995
42996 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42997 PyObject *resultobj = 0;
42998 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42999 wxString *arg2 = 0 ;
43000 void *argp1 = 0 ;
43001 int res1 = 0 ;
43002 bool temp2 = false ;
43003 PyObject * obj0 = 0 ;
43004 PyObject * obj1 = 0 ;
43005 char * kwnames[] = {
43006 (char *) "self",(char *) "str", NULL
43007 };
43008
43009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43011 if (!SWIG_IsOK(res1)) {
43012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43013 }
43014 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43015 {
43016 arg2 = wxString_in_helper(obj1);
43017 if (arg2 == NULL) SWIG_fail;
43018 temp2 = true;
43019 }
43020 {
43021 PyThreadState* __tstate = wxPyBeginAllowThreads();
43022 (arg1)->SetHelp((wxString const &)*arg2);
43023 wxPyEndAllowThreads(__tstate);
43024 if (PyErr_Occurred()) SWIG_fail;
43025 }
43026 resultobj = SWIG_Py_Void();
43027 {
43028 if (temp2)
43029 delete arg2;
43030 }
43031 return resultobj;
43032 fail:
43033 {
43034 if (temp2)
43035 delete arg2;
43036 }
43037 return NULL;
43038 }
43039
43040
43041 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43042 PyObject *resultobj = 0;
43043 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43044 wxString *result = 0 ;
43045 void *argp1 = 0 ;
43046 int res1 = 0 ;
43047 PyObject *swig_obj[1] ;
43048
43049 if (!args) SWIG_fail;
43050 swig_obj[0] = args;
43051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43052 if (!SWIG_IsOK(res1)) {
43053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43054 }
43055 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43056 {
43057 PyThreadState* __tstate = wxPyBeginAllowThreads();
43058 {
43059 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43060 result = (wxString *) &_result_ref;
43061 }
43062 wxPyEndAllowThreads(__tstate);
43063 if (PyErr_Occurred()) SWIG_fail;
43064 }
43065 {
43066 #if wxUSE_UNICODE
43067 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43068 #else
43069 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43070 #endif
43071 }
43072 return resultobj;
43073 fail:
43074 return NULL;
43075 }
43076
43077
43078 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43079 PyObject *resultobj = 0;
43080 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43081 wxAcceleratorEntry *result = 0 ;
43082 void *argp1 = 0 ;
43083 int res1 = 0 ;
43084 PyObject *swig_obj[1] ;
43085
43086 if (!args) SWIG_fail;
43087 swig_obj[0] = args;
43088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43089 if (!SWIG_IsOK(res1)) {
43090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43091 }
43092 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43093 {
43094 PyThreadState* __tstate = wxPyBeginAllowThreads();
43095 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43096 wxPyEndAllowThreads(__tstate);
43097 if (PyErr_Occurred()) SWIG_fail;
43098 }
43099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43100 return resultobj;
43101 fail:
43102 return NULL;
43103 }
43104
43105
43106 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43107 PyObject *resultobj = 0;
43108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43109 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43110 void *argp1 = 0 ;
43111 int res1 = 0 ;
43112 void *argp2 = 0 ;
43113 int res2 = 0 ;
43114 PyObject * obj0 = 0 ;
43115 PyObject * obj1 = 0 ;
43116 char * kwnames[] = {
43117 (char *) "self",(char *) "accel", NULL
43118 };
43119
43120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43122 if (!SWIG_IsOK(res1)) {
43123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43124 }
43125 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43127 if (!SWIG_IsOK(res2)) {
43128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43129 }
43130 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43131 {
43132 PyThreadState* __tstate = wxPyBeginAllowThreads();
43133 (arg1)->SetAccel(arg2);
43134 wxPyEndAllowThreads(__tstate);
43135 if (PyErr_Occurred()) SWIG_fail;
43136 }
43137 resultobj = SWIG_Py_Void();
43138 return resultobj;
43139 fail:
43140 return NULL;
43141 }
43142
43143
43144 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43145 PyObject *resultobj = 0;
43146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43147 wxBitmap *arg2 = 0 ;
43148 void *argp1 = 0 ;
43149 int res1 = 0 ;
43150 void *argp2 = 0 ;
43151 int res2 = 0 ;
43152 PyObject * obj0 = 0 ;
43153 PyObject * obj1 = 0 ;
43154 char * kwnames[] = {
43155 (char *) "self",(char *) "bitmap", NULL
43156 };
43157
43158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43160 if (!SWIG_IsOK(res1)) {
43161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43162 }
43163 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43164 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43165 if (!SWIG_IsOK(res2)) {
43166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43167 }
43168 if (!argp2) {
43169 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43170 }
43171 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43172 {
43173 PyThreadState* __tstate = wxPyBeginAllowThreads();
43174 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43175 wxPyEndAllowThreads(__tstate);
43176 if (PyErr_Occurred()) SWIG_fail;
43177 }
43178 resultobj = SWIG_Py_Void();
43179 return resultobj;
43180 fail:
43181 return NULL;
43182 }
43183
43184
43185 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43186 PyObject *resultobj = 0;
43187 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43188 wxBitmap *result = 0 ;
43189 void *argp1 = 0 ;
43190 int res1 = 0 ;
43191 PyObject *swig_obj[1] ;
43192
43193 if (!args) SWIG_fail;
43194 swig_obj[0] = args;
43195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43196 if (!SWIG_IsOK(res1)) {
43197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43198 }
43199 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43200 {
43201 PyThreadState* __tstate = wxPyBeginAllowThreads();
43202 {
43203 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43204 result = (wxBitmap *) &_result_ref;
43205 }
43206 wxPyEndAllowThreads(__tstate);
43207 if (PyErr_Occurred()) SWIG_fail;
43208 }
43209 {
43210 wxBitmap* resultptr = new wxBitmap(*result);
43211 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43212 }
43213 return resultobj;
43214 fail:
43215 return NULL;
43216 }
43217
43218
43219 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43220 PyObject *resultobj = 0;
43221 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43222 wxFont *arg2 = 0 ;
43223 void *argp1 = 0 ;
43224 int res1 = 0 ;
43225 void *argp2 = 0 ;
43226 int res2 = 0 ;
43227 PyObject * obj0 = 0 ;
43228 PyObject * obj1 = 0 ;
43229 char * kwnames[] = {
43230 (char *) "self",(char *) "font", NULL
43231 };
43232
43233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43235 if (!SWIG_IsOK(res1)) {
43236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43237 }
43238 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43239 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43240 if (!SWIG_IsOK(res2)) {
43241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43242 }
43243 if (!argp2) {
43244 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43245 }
43246 arg2 = reinterpret_cast< wxFont * >(argp2);
43247 {
43248 PyThreadState* __tstate = wxPyBeginAllowThreads();
43249 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43250 wxPyEndAllowThreads(__tstate);
43251 if (PyErr_Occurred()) SWIG_fail;
43252 }
43253 resultobj = SWIG_Py_Void();
43254 return resultobj;
43255 fail:
43256 return NULL;
43257 }
43258
43259
43260 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43261 PyObject *resultobj = 0;
43262 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43263 wxFont result;
43264 void *argp1 = 0 ;
43265 int res1 = 0 ;
43266 PyObject *swig_obj[1] ;
43267
43268 if (!args) SWIG_fail;
43269 swig_obj[0] = args;
43270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43271 if (!SWIG_IsOK(res1)) {
43272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43273 }
43274 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43275 {
43276 PyThreadState* __tstate = wxPyBeginAllowThreads();
43277 result = wxMenuItem_GetFont(arg1);
43278 wxPyEndAllowThreads(__tstate);
43279 if (PyErr_Occurred()) SWIG_fail;
43280 }
43281 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43282 return resultobj;
43283 fail:
43284 return NULL;
43285 }
43286
43287
43288 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43289 PyObject *resultobj = 0;
43290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43291 wxColour *arg2 = 0 ;
43292 void *argp1 = 0 ;
43293 int res1 = 0 ;
43294 wxColour temp2 ;
43295 PyObject * obj0 = 0 ;
43296 PyObject * obj1 = 0 ;
43297 char * kwnames[] = {
43298 (char *) "self",(char *) "colText", NULL
43299 };
43300
43301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43303 if (!SWIG_IsOK(res1)) {
43304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43305 }
43306 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43307 {
43308 arg2 = &temp2;
43309 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43310 }
43311 {
43312 PyThreadState* __tstate = wxPyBeginAllowThreads();
43313 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43314 wxPyEndAllowThreads(__tstate);
43315 if (PyErr_Occurred()) SWIG_fail;
43316 }
43317 resultobj = SWIG_Py_Void();
43318 return resultobj;
43319 fail:
43320 return NULL;
43321 }
43322
43323
43324 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43325 PyObject *resultobj = 0;
43326 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43327 wxColour result;
43328 void *argp1 = 0 ;
43329 int res1 = 0 ;
43330 PyObject *swig_obj[1] ;
43331
43332 if (!args) SWIG_fail;
43333 swig_obj[0] = args;
43334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43335 if (!SWIG_IsOK(res1)) {
43336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43337 }
43338 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43339 {
43340 PyThreadState* __tstate = wxPyBeginAllowThreads();
43341 result = wxMenuItem_GetTextColour(arg1);
43342 wxPyEndAllowThreads(__tstate);
43343 if (PyErr_Occurred()) SWIG_fail;
43344 }
43345 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43346 return resultobj;
43347 fail:
43348 return NULL;
43349 }
43350
43351
43352 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43353 PyObject *resultobj = 0;
43354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43355 wxColour *arg2 = 0 ;
43356 void *argp1 = 0 ;
43357 int res1 = 0 ;
43358 wxColour temp2 ;
43359 PyObject * obj0 = 0 ;
43360 PyObject * obj1 = 0 ;
43361 char * kwnames[] = {
43362 (char *) "self",(char *) "colBack", NULL
43363 };
43364
43365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43367 if (!SWIG_IsOK(res1)) {
43368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43369 }
43370 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43371 {
43372 arg2 = &temp2;
43373 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43374 }
43375 {
43376 PyThreadState* __tstate = wxPyBeginAllowThreads();
43377 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43378 wxPyEndAllowThreads(__tstate);
43379 if (PyErr_Occurred()) SWIG_fail;
43380 }
43381 resultobj = SWIG_Py_Void();
43382 return resultobj;
43383 fail:
43384 return NULL;
43385 }
43386
43387
43388 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43389 PyObject *resultobj = 0;
43390 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43391 wxColour result;
43392 void *argp1 = 0 ;
43393 int res1 = 0 ;
43394 PyObject *swig_obj[1] ;
43395
43396 if (!args) SWIG_fail;
43397 swig_obj[0] = args;
43398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43399 if (!SWIG_IsOK(res1)) {
43400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43401 }
43402 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43403 {
43404 PyThreadState* __tstate = wxPyBeginAllowThreads();
43405 result = wxMenuItem_GetBackgroundColour(arg1);
43406 wxPyEndAllowThreads(__tstate);
43407 if (PyErr_Occurred()) SWIG_fail;
43408 }
43409 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43410 return resultobj;
43411 fail:
43412 return NULL;
43413 }
43414
43415
43416 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43417 PyObject *resultobj = 0;
43418 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43419 wxBitmap *arg2 = 0 ;
43420 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43421 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43422 void *argp1 = 0 ;
43423 int res1 = 0 ;
43424 void *argp2 = 0 ;
43425 int res2 = 0 ;
43426 void *argp3 = 0 ;
43427 int res3 = 0 ;
43428 PyObject * obj0 = 0 ;
43429 PyObject * obj1 = 0 ;
43430 PyObject * obj2 = 0 ;
43431 char * kwnames[] = {
43432 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43433 };
43434
43435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43437 if (!SWIG_IsOK(res1)) {
43438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43439 }
43440 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43441 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43442 if (!SWIG_IsOK(res2)) {
43443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43444 }
43445 if (!argp2) {
43446 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43447 }
43448 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43449 if (obj2) {
43450 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43451 if (!SWIG_IsOK(res3)) {
43452 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43453 }
43454 if (!argp3) {
43455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43456 }
43457 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43458 }
43459 {
43460 PyThreadState* __tstate = wxPyBeginAllowThreads();
43461 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43462 wxPyEndAllowThreads(__tstate);
43463 if (PyErr_Occurred()) SWIG_fail;
43464 }
43465 resultobj = SWIG_Py_Void();
43466 return resultobj;
43467 fail:
43468 return NULL;
43469 }
43470
43471
43472 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43473 PyObject *resultobj = 0;
43474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43475 wxBitmap *arg2 = 0 ;
43476 void *argp1 = 0 ;
43477 int res1 = 0 ;
43478 void *argp2 = 0 ;
43479 int res2 = 0 ;
43480 PyObject * obj0 = 0 ;
43481 PyObject * obj1 = 0 ;
43482 char * kwnames[] = {
43483 (char *) "self",(char *) "bmpDisabled", NULL
43484 };
43485
43486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43488 if (!SWIG_IsOK(res1)) {
43489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43490 }
43491 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43493 if (!SWIG_IsOK(res2)) {
43494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43495 }
43496 if (!argp2) {
43497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43498 }
43499 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43500 {
43501 PyThreadState* __tstate = wxPyBeginAllowThreads();
43502 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43503 wxPyEndAllowThreads(__tstate);
43504 if (PyErr_Occurred()) SWIG_fail;
43505 }
43506 resultobj = SWIG_Py_Void();
43507 return resultobj;
43508 fail:
43509 return NULL;
43510 }
43511
43512
43513 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43514 PyObject *resultobj = 0;
43515 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43516 wxBitmap *result = 0 ;
43517 void *argp1 = 0 ;
43518 int res1 = 0 ;
43519 PyObject *swig_obj[1] ;
43520
43521 if (!args) SWIG_fail;
43522 swig_obj[0] = args;
43523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43524 if (!SWIG_IsOK(res1)) {
43525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43526 }
43527 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43528 {
43529 PyThreadState* __tstate = wxPyBeginAllowThreads();
43530 {
43531 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43532 result = (wxBitmap *) &_result_ref;
43533 }
43534 wxPyEndAllowThreads(__tstate);
43535 if (PyErr_Occurred()) SWIG_fail;
43536 }
43537 {
43538 wxBitmap* resultptr = new wxBitmap(*result);
43539 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43540 }
43541 return resultobj;
43542 fail:
43543 return NULL;
43544 }
43545
43546
43547 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43548 PyObject *resultobj = 0;
43549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43550 int arg2 ;
43551 void *argp1 = 0 ;
43552 int res1 = 0 ;
43553 int val2 ;
43554 int ecode2 = 0 ;
43555 PyObject * obj0 = 0 ;
43556 PyObject * obj1 = 0 ;
43557 char * kwnames[] = {
43558 (char *) "self",(char *) "nWidth", NULL
43559 };
43560
43561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43563 if (!SWIG_IsOK(res1)) {
43564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43565 }
43566 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43567 ecode2 = SWIG_AsVal_int(obj1, &val2);
43568 if (!SWIG_IsOK(ecode2)) {
43569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43570 }
43571 arg2 = static_cast< int >(val2);
43572 {
43573 PyThreadState* __tstate = wxPyBeginAllowThreads();
43574 wxMenuItem_SetMarginWidth(arg1,arg2);
43575 wxPyEndAllowThreads(__tstate);
43576 if (PyErr_Occurred()) SWIG_fail;
43577 }
43578 resultobj = SWIG_Py_Void();
43579 return resultobj;
43580 fail:
43581 return NULL;
43582 }
43583
43584
43585 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43586 PyObject *resultobj = 0;
43587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43588 int result;
43589 void *argp1 = 0 ;
43590 int res1 = 0 ;
43591 PyObject *swig_obj[1] ;
43592
43593 if (!args) SWIG_fail;
43594 swig_obj[0] = args;
43595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43596 if (!SWIG_IsOK(res1)) {
43597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43598 }
43599 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43600 {
43601 PyThreadState* __tstate = wxPyBeginAllowThreads();
43602 result = (int)wxMenuItem_GetMarginWidth(arg1);
43603 wxPyEndAllowThreads(__tstate);
43604 if (PyErr_Occurred()) SWIG_fail;
43605 }
43606 resultobj = SWIG_From_int(static_cast< int >(result));
43607 return resultobj;
43608 fail:
43609 return NULL;
43610 }
43611
43612
43613 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43614 PyObject *resultobj = 0;
43615 int result;
43616
43617 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43618 {
43619 PyThreadState* __tstate = wxPyBeginAllowThreads();
43620 result = (int)wxMenuItem_GetDefaultMarginWidth();
43621 wxPyEndAllowThreads(__tstate);
43622 if (PyErr_Occurred()) SWIG_fail;
43623 }
43624 resultobj = SWIG_From_int(static_cast< int >(result));
43625 return resultobj;
43626 fail:
43627 return NULL;
43628 }
43629
43630
43631 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43632 PyObject *resultobj = 0;
43633 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43634 bool result;
43635 void *argp1 = 0 ;
43636 int res1 = 0 ;
43637 PyObject *swig_obj[1] ;
43638
43639 if (!args) SWIG_fail;
43640 swig_obj[0] = args;
43641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43642 if (!SWIG_IsOK(res1)) {
43643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43644 }
43645 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43646 {
43647 PyThreadState* __tstate = wxPyBeginAllowThreads();
43648 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43649 wxPyEndAllowThreads(__tstate);
43650 if (PyErr_Occurred()) SWIG_fail;
43651 }
43652 {
43653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43654 }
43655 return resultobj;
43656 fail:
43657 return NULL;
43658 }
43659
43660
43661 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43662 PyObject *resultobj = 0;
43663 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43664 bool arg2 = (bool) true ;
43665 void *argp1 = 0 ;
43666 int res1 = 0 ;
43667 bool val2 ;
43668 int ecode2 = 0 ;
43669 PyObject * obj0 = 0 ;
43670 PyObject * obj1 = 0 ;
43671 char * kwnames[] = {
43672 (char *) "self",(char *) "ownerDrawn", NULL
43673 };
43674
43675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43677 if (!SWIG_IsOK(res1)) {
43678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43679 }
43680 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43681 if (obj1) {
43682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43683 if (!SWIG_IsOK(ecode2)) {
43684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43685 }
43686 arg2 = static_cast< bool >(val2);
43687 }
43688 {
43689 PyThreadState* __tstate = wxPyBeginAllowThreads();
43690 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43691 wxPyEndAllowThreads(__tstate);
43692 if (PyErr_Occurred()) SWIG_fail;
43693 }
43694 resultobj = SWIG_Py_Void();
43695 return resultobj;
43696 fail:
43697 return NULL;
43698 }
43699
43700
43701 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43702 PyObject *resultobj = 0;
43703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43704 void *argp1 = 0 ;
43705 int res1 = 0 ;
43706 PyObject *swig_obj[1] ;
43707
43708 if (!args) SWIG_fail;
43709 swig_obj[0] = args;
43710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43711 if (!SWIG_IsOK(res1)) {
43712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43713 }
43714 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43715 {
43716 PyThreadState* __tstate = wxPyBeginAllowThreads();
43717 wxMenuItem_ResetOwnerDrawn(arg1);
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 *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43729 PyObject *obj;
43730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43731 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43732 return SWIG_Py_Void();
43733 }
43734
43735 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43736 return SWIG_Python_InitShadowInstance(args);
43737 }
43738
43739 SWIGINTERN int ControlNameStr_set(PyObject *) {
43740 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43741 return 1;
43742 }
43743
43744
43745 SWIGINTERN PyObject *ControlNameStr_get(void) {
43746 PyObject *pyobj = 0;
43747
43748 {
43749 #if wxUSE_UNICODE
43750 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43751 #else
43752 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43753 #endif
43754 }
43755 return pyobj;
43756 }
43757
43758
43759 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43760 PyObject *resultobj = 0;
43761 wxWindow *arg1 = (wxWindow *) 0 ;
43762 int arg2 = (int) -1 ;
43763 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43764 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43765 wxSize const &arg4_defvalue = wxDefaultSize ;
43766 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43767 long arg5 = (long) 0 ;
43768 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43769 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43770 wxString const &arg7_defvalue = wxPyControlNameStr ;
43771 wxString *arg7 = (wxString *) &arg7_defvalue ;
43772 wxControl *result = 0 ;
43773 void *argp1 = 0 ;
43774 int res1 = 0 ;
43775 int val2 ;
43776 int ecode2 = 0 ;
43777 wxPoint temp3 ;
43778 wxSize temp4 ;
43779 long val5 ;
43780 int ecode5 = 0 ;
43781 void *argp6 = 0 ;
43782 int res6 = 0 ;
43783 bool temp7 = false ;
43784 PyObject * obj0 = 0 ;
43785 PyObject * obj1 = 0 ;
43786 PyObject * obj2 = 0 ;
43787 PyObject * obj3 = 0 ;
43788 PyObject * obj4 = 0 ;
43789 PyObject * obj5 = 0 ;
43790 PyObject * obj6 = 0 ;
43791 char * kwnames[] = {
43792 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43793 };
43794
43795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43797 if (!SWIG_IsOK(res1)) {
43798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43799 }
43800 arg1 = reinterpret_cast< wxWindow * >(argp1);
43801 if (obj1) {
43802 ecode2 = SWIG_AsVal_int(obj1, &val2);
43803 if (!SWIG_IsOK(ecode2)) {
43804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43805 }
43806 arg2 = static_cast< int >(val2);
43807 }
43808 if (obj2) {
43809 {
43810 arg3 = &temp3;
43811 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43812 }
43813 }
43814 if (obj3) {
43815 {
43816 arg4 = &temp4;
43817 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43818 }
43819 }
43820 if (obj4) {
43821 ecode5 = SWIG_AsVal_long(obj4, &val5);
43822 if (!SWIG_IsOK(ecode5)) {
43823 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43824 }
43825 arg5 = static_cast< long >(val5);
43826 }
43827 if (obj5) {
43828 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43829 if (!SWIG_IsOK(res6)) {
43830 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43831 }
43832 if (!argp6) {
43833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43834 }
43835 arg6 = reinterpret_cast< wxValidator * >(argp6);
43836 }
43837 if (obj6) {
43838 {
43839 arg7 = wxString_in_helper(obj6);
43840 if (arg7 == NULL) SWIG_fail;
43841 temp7 = true;
43842 }
43843 }
43844 {
43845 if (!wxPyCheckForApp()) SWIG_fail;
43846 PyThreadState* __tstate = wxPyBeginAllowThreads();
43847 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43848 wxPyEndAllowThreads(__tstate);
43849 if (PyErr_Occurred()) SWIG_fail;
43850 }
43851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43852 {
43853 if (temp7)
43854 delete arg7;
43855 }
43856 return resultobj;
43857 fail:
43858 {
43859 if (temp7)
43860 delete arg7;
43861 }
43862 return NULL;
43863 }
43864
43865
43866 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43867 PyObject *resultobj = 0;
43868 wxControl *result = 0 ;
43869
43870 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43871 {
43872 if (!wxPyCheckForApp()) SWIG_fail;
43873 PyThreadState* __tstate = wxPyBeginAllowThreads();
43874 result = (wxControl *)new wxControl();
43875 wxPyEndAllowThreads(__tstate);
43876 if (PyErr_Occurred()) SWIG_fail;
43877 }
43878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43879 return resultobj;
43880 fail:
43881 return NULL;
43882 }
43883
43884
43885 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43886 PyObject *resultobj = 0;
43887 wxControl *arg1 = (wxControl *) 0 ;
43888 wxWindow *arg2 = (wxWindow *) 0 ;
43889 int arg3 = (int) -1 ;
43890 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43891 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43892 wxSize const &arg5_defvalue = wxDefaultSize ;
43893 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43894 long arg6 = (long) 0 ;
43895 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43896 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43897 wxString const &arg8_defvalue = wxPyControlNameStr ;
43898 wxString *arg8 = (wxString *) &arg8_defvalue ;
43899 bool result;
43900 void *argp1 = 0 ;
43901 int res1 = 0 ;
43902 void *argp2 = 0 ;
43903 int res2 = 0 ;
43904 int val3 ;
43905 int ecode3 = 0 ;
43906 wxPoint temp4 ;
43907 wxSize temp5 ;
43908 long val6 ;
43909 int ecode6 = 0 ;
43910 void *argp7 = 0 ;
43911 int res7 = 0 ;
43912 bool temp8 = false ;
43913 PyObject * obj0 = 0 ;
43914 PyObject * obj1 = 0 ;
43915 PyObject * obj2 = 0 ;
43916 PyObject * obj3 = 0 ;
43917 PyObject * obj4 = 0 ;
43918 PyObject * obj5 = 0 ;
43919 PyObject * obj6 = 0 ;
43920 PyObject * obj7 = 0 ;
43921 char * kwnames[] = {
43922 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43923 };
43924
43925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43927 if (!SWIG_IsOK(res1)) {
43928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43929 }
43930 arg1 = reinterpret_cast< wxControl * >(argp1);
43931 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43932 if (!SWIG_IsOK(res2)) {
43933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43934 }
43935 arg2 = reinterpret_cast< wxWindow * >(argp2);
43936 if (obj2) {
43937 ecode3 = SWIG_AsVal_int(obj2, &val3);
43938 if (!SWIG_IsOK(ecode3)) {
43939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43940 }
43941 arg3 = static_cast< int >(val3);
43942 }
43943 if (obj3) {
43944 {
43945 arg4 = &temp4;
43946 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43947 }
43948 }
43949 if (obj4) {
43950 {
43951 arg5 = &temp5;
43952 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43953 }
43954 }
43955 if (obj5) {
43956 ecode6 = SWIG_AsVal_long(obj5, &val6);
43957 if (!SWIG_IsOK(ecode6)) {
43958 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43959 }
43960 arg6 = static_cast< long >(val6);
43961 }
43962 if (obj6) {
43963 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43964 if (!SWIG_IsOK(res7)) {
43965 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43966 }
43967 if (!argp7) {
43968 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43969 }
43970 arg7 = reinterpret_cast< wxValidator * >(argp7);
43971 }
43972 if (obj7) {
43973 {
43974 arg8 = wxString_in_helper(obj7);
43975 if (arg8 == NULL) SWIG_fail;
43976 temp8 = true;
43977 }
43978 }
43979 {
43980 PyThreadState* __tstate = wxPyBeginAllowThreads();
43981 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43982 wxPyEndAllowThreads(__tstate);
43983 if (PyErr_Occurred()) SWIG_fail;
43984 }
43985 {
43986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43987 }
43988 {
43989 if (temp8)
43990 delete arg8;
43991 }
43992 return resultobj;
43993 fail:
43994 {
43995 if (temp8)
43996 delete arg8;
43997 }
43998 return NULL;
43999 }
44000
44001
44002 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44003 PyObject *resultobj = 0;
44004 wxControl *arg1 = (wxControl *) 0 ;
44005 wxCommandEvent *arg2 = 0 ;
44006 void *argp1 = 0 ;
44007 int res1 = 0 ;
44008 void *argp2 = 0 ;
44009 int res2 = 0 ;
44010 PyObject * obj0 = 0 ;
44011 PyObject * obj1 = 0 ;
44012 char * kwnames[] = {
44013 (char *) "self",(char *) "event", NULL
44014 };
44015
44016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44018 if (!SWIG_IsOK(res1)) {
44019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44020 }
44021 arg1 = reinterpret_cast< wxControl * >(argp1);
44022 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44023 if (!SWIG_IsOK(res2)) {
44024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44025 }
44026 if (!argp2) {
44027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44028 }
44029 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44030 {
44031 PyThreadState* __tstate = wxPyBeginAllowThreads();
44032 (arg1)->Command(*arg2);
44033 wxPyEndAllowThreads(__tstate);
44034 if (PyErr_Occurred()) SWIG_fail;
44035 }
44036 resultobj = SWIG_Py_Void();
44037 return resultobj;
44038 fail:
44039 return NULL;
44040 }
44041
44042
44043 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44044 PyObject *resultobj = 0;
44045 wxControl *arg1 = (wxControl *) 0 ;
44046 wxString result;
44047 void *argp1 = 0 ;
44048 int res1 = 0 ;
44049 PyObject *swig_obj[1] ;
44050
44051 if (!args) SWIG_fail;
44052 swig_obj[0] = args;
44053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44054 if (!SWIG_IsOK(res1)) {
44055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44056 }
44057 arg1 = reinterpret_cast< wxControl * >(argp1);
44058 {
44059 PyThreadState* __tstate = wxPyBeginAllowThreads();
44060 result = (arg1)->GetLabel();
44061 wxPyEndAllowThreads(__tstate);
44062 if (PyErr_Occurred()) SWIG_fail;
44063 }
44064 {
44065 #if wxUSE_UNICODE
44066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44067 #else
44068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44069 #endif
44070 }
44071 return resultobj;
44072 fail:
44073 return NULL;
44074 }
44075
44076
44077 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44078 PyObject *resultobj = 0;
44079 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44080 SwigValueWrapper<wxVisualAttributes > result;
44081 int val1 ;
44082 int ecode1 = 0 ;
44083 PyObject * obj0 = 0 ;
44084 char * kwnames[] = {
44085 (char *) "variant", NULL
44086 };
44087
44088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44089 if (obj0) {
44090 ecode1 = SWIG_AsVal_int(obj0, &val1);
44091 if (!SWIG_IsOK(ecode1)) {
44092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44093 }
44094 arg1 = static_cast< wxWindowVariant >(val1);
44095 }
44096 {
44097 if (!wxPyCheckForApp()) SWIG_fail;
44098 PyThreadState* __tstate = wxPyBeginAllowThreads();
44099 result = wxControl::GetClassDefaultAttributes(arg1);
44100 wxPyEndAllowThreads(__tstate);
44101 if (PyErr_Occurred()) SWIG_fail;
44102 }
44103 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44104 return resultobj;
44105 fail:
44106 return NULL;
44107 }
44108
44109
44110 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44111 PyObject *obj;
44112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44113 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44114 return SWIG_Py_Void();
44115 }
44116
44117 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44118 return SWIG_Python_InitShadowInstance(args);
44119 }
44120
44121 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44122 PyObject *resultobj = 0;
44123 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44124 wxString *arg2 = 0 ;
44125 PyObject *arg3 = (PyObject *) NULL ;
44126 int result;
44127 void *argp1 = 0 ;
44128 int res1 = 0 ;
44129 bool temp2 = false ;
44130 PyObject * obj0 = 0 ;
44131 PyObject * obj1 = 0 ;
44132 PyObject * obj2 = 0 ;
44133 char * kwnames[] = {
44134 (char *) "self",(char *) "item",(char *) "clientData", NULL
44135 };
44136
44137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44139 if (!SWIG_IsOK(res1)) {
44140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44141 }
44142 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44143 {
44144 arg2 = wxString_in_helper(obj1);
44145 if (arg2 == NULL) SWIG_fail;
44146 temp2 = true;
44147 }
44148 if (obj2) {
44149 arg3 = obj2;
44150 }
44151 {
44152 PyThreadState* __tstate = wxPyBeginAllowThreads();
44153 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44154 wxPyEndAllowThreads(__tstate);
44155 if (PyErr_Occurred()) SWIG_fail;
44156 }
44157 resultobj = SWIG_From_int(static_cast< int >(result));
44158 {
44159 if (temp2)
44160 delete arg2;
44161 }
44162 return resultobj;
44163 fail:
44164 {
44165 if (temp2)
44166 delete arg2;
44167 }
44168 return NULL;
44169 }
44170
44171
44172 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44173 PyObject *resultobj = 0;
44174 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44175 wxArrayString *arg2 = 0 ;
44176 void *argp1 = 0 ;
44177 int res1 = 0 ;
44178 bool temp2 = false ;
44179 PyObject * obj0 = 0 ;
44180 PyObject * obj1 = 0 ;
44181 char * kwnames[] = {
44182 (char *) "self",(char *) "strings", NULL
44183 };
44184
44185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44187 if (!SWIG_IsOK(res1)) {
44188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44189 }
44190 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44191 {
44192 if (! PySequence_Check(obj1)) {
44193 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44194 SWIG_fail;
44195 }
44196 arg2 = new wxArrayString;
44197 temp2 = true;
44198 int i, len=PySequence_Length(obj1);
44199 for (i=0; i<len; i++) {
44200 PyObject* item = PySequence_GetItem(obj1, i);
44201 wxString* s = wxString_in_helper(item);
44202 if (PyErr_Occurred()) SWIG_fail;
44203 arg2->Add(*s);
44204 delete s;
44205 Py_DECREF(item);
44206 }
44207 }
44208 {
44209 PyThreadState* __tstate = wxPyBeginAllowThreads();
44210 (arg1)->Append((wxArrayString const &)*arg2);
44211 wxPyEndAllowThreads(__tstate);
44212 if (PyErr_Occurred()) SWIG_fail;
44213 }
44214 resultobj = SWIG_Py_Void();
44215 {
44216 if (temp2) delete arg2;
44217 }
44218 return resultobj;
44219 fail:
44220 {
44221 if (temp2) delete arg2;
44222 }
44223 return NULL;
44224 }
44225
44226
44227 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44228 PyObject *resultobj = 0;
44229 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44230 wxString *arg2 = 0 ;
44231 unsigned int arg3 ;
44232 PyObject *arg4 = (PyObject *) NULL ;
44233 int result;
44234 void *argp1 = 0 ;
44235 int res1 = 0 ;
44236 bool temp2 = false ;
44237 unsigned int val3 ;
44238 int ecode3 = 0 ;
44239 PyObject * obj0 = 0 ;
44240 PyObject * obj1 = 0 ;
44241 PyObject * obj2 = 0 ;
44242 PyObject * obj3 = 0 ;
44243 char * kwnames[] = {
44244 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44245 };
44246
44247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44249 if (!SWIG_IsOK(res1)) {
44250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44251 }
44252 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44253 {
44254 arg2 = wxString_in_helper(obj1);
44255 if (arg2 == NULL) SWIG_fail;
44256 temp2 = true;
44257 }
44258 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44259 if (!SWIG_IsOK(ecode3)) {
44260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44261 }
44262 arg3 = static_cast< unsigned int >(val3);
44263 if (obj3) {
44264 arg4 = obj3;
44265 }
44266 {
44267 PyThreadState* __tstate = wxPyBeginAllowThreads();
44268 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44269 wxPyEndAllowThreads(__tstate);
44270 if (PyErr_Occurred()) SWIG_fail;
44271 }
44272 resultobj = SWIG_From_int(static_cast< int >(result));
44273 {
44274 if (temp2)
44275 delete arg2;
44276 }
44277 return resultobj;
44278 fail:
44279 {
44280 if (temp2)
44281 delete arg2;
44282 }
44283 return NULL;
44284 }
44285
44286
44287 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44288 PyObject *resultobj = 0;
44289 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44290 void *argp1 = 0 ;
44291 int res1 = 0 ;
44292 PyObject *swig_obj[1] ;
44293
44294 if (!args) SWIG_fail;
44295 swig_obj[0] = args;
44296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44297 if (!SWIG_IsOK(res1)) {
44298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44299 }
44300 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44301 {
44302 PyThreadState* __tstate = wxPyBeginAllowThreads();
44303 (arg1)->Clear();
44304 wxPyEndAllowThreads(__tstate);
44305 if (PyErr_Occurred()) SWIG_fail;
44306 }
44307 resultobj = SWIG_Py_Void();
44308 return resultobj;
44309 fail:
44310 return NULL;
44311 }
44312
44313
44314 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44315 PyObject *resultobj = 0;
44316 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44317 unsigned int arg2 ;
44318 void *argp1 = 0 ;
44319 int res1 = 0 ;
44320 unsigned int val2 ;
44321 int ecode2 = 0 ;
44322 PyObject * obj0 = 0 ;
44323 PyObject * obj1 = 0 ;
44324 char * kwnames[] = {
44325 (char *) "self",(char *) "n", NULL
44326 };
44327
44328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44330 if (!SWIG_IsOK(res1)) {
44331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44332 }
44333 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44334 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44335 if (!SWIG_IsOK(ecode2)) {
44336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44337 }
44338 arg2 = static_cast< unsigned int >(val2);
44339 {
44340 PyThreadState* __tstate = wxPyBeginAllowThreads();
44341 (arg1)->Delete(arg2);
44342 wxPyEndAllowThreads(__tstate);
44343 if (PyErr_Occurred()) SWIG_fail;
44344 }
44345 resultobj = SWIG_Py_Void();
44346 return resultobj;
44347 fail:
44348 return NULL;
44349 }
44350
44351
44352 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44353 PyObject *resultobj = 0;
44354 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44355 unsigned int arg2 ;
44356 PyObject *result = 0 ;
44357 void *argp1 = 0 ;
44358 int res1 = 0 ;
44359 unsigned int val2 ;
44360 int ecode2 = 0 ;
44361 PyObject * obj0 = 0 ;
44362 PyObject * obj1 = 0 ;
44363 char * kwnames[] = {
44364 (char *) "self",(char *) "n", NULL
44365 };
44366
44367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44369 if (!SWIG_IsOK(res1)) {
44370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44371 }
44372 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44373 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44374 if (!SWIG_IsOK(ecode2)) {
44375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44376 }
44377 arg2 = static_cast< unsigned int >(val2);
44378 {
44379 PyThreadState* __tstate = wxPyBeginAllowThreads();
44380 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44381 wxPyEndAllowThreads(__tstate);
44382 if (PyErr_Occurred()) SWIG_fail;
44383 }
44384 resultobj = result;
44385 return resultobj;
44386 fail:
44387 return NULL;
44388 }
44389
44390
44391 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44392 PyObject *resultobj = 0;
44393 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44394 unsigned int arg2 ;
44395 PyObject *arg3 = (PyObject *) 0 ;
44396 void *argp1 = 0 ;
44397 int res1 = 0 ;
44398 unsigned int val2 ;
44399 int ecode2 = 0 ;
44400 PyObject * obj0 = 0 ;
44401 PyObject * obj1 = 0 ;
44402 PyObject * obj2 = 0 ;
44403 char * kwnames[] = {
44404 (char *) "self",(char *) "n",(char *) "clientData", NULL
44405 };
44406
44407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44409 if (!SWIG_IsOK(res1)) {
44410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44411 }
44412 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44413 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44414 if (!SWIG_IsOK(ecode2)) {
44415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44416 }
44417 arg2 = static_cast< unsigned int >(val2);
44418 arg3 = obj2;
44419 {
44420 PyThreadState* __tstate = wxPyBeginAllowThreads();
44421 wxItemContainer_SetClientData(arg1,arg2,arg3);
44422 wxPyEndAllowThreads(__tstate);
44423 if (PyErr_Occurred()) SWIG_fail;
44424 }
44425 resultobj = SWIG_Py_Void();
44426 return resultobj;
44427 fail:
44428 return NULL;
44429 }
44430
44431
44432 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44433 PyObject *resultobj = 0;
44434 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44435 unsigned int result;
44436 void *argp1 = 0 ;
44437 int res1 = 0 ;
44438 PyObject *swig_obj[1] ;
44439
44440 if (!args) SWIG_fail;
44441 swig_obj[0] = args;
44442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44443 if (!SWIG_IsOK(res1)) {
44444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44445 }
44446 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44447 {
44448 PyThreadState* __tstate = wxPyBeginAllowThreads();
44449 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44450 wxPyEndAllowThreads(__tstate);
44451 if (PyErr_Occurred()) SWIG_fail;
44452 }
44453 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44454 return resultobj;
44455 fail:
44456 return NULL;
44457 }
44458
44459
44460 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44461 PyObject *resultobj = 0;
44462 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44463 bool result;
44464 void *argp1 = 0 ;
44465 int res1 = 0 ;
44466 PyObject *swig_obj[1] ;
44467
44468 if (!args) SWIG_fail;
44469 swig_obj[0] = args;
44470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44471 if (!SWIG_IsOK(res1)) {
44472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44473 }
44474 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44475 {
44476 PyThreadState* __tstate = wxPyBeginAllowThreads();
44477 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44478 wxPyEndAllowThreads(__tstate);
44479 if (PyErr_Occurred()) SWIG_fail;
44480 }
44481 {
44482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44483 }
44484 return resultobj;
44485 fail:
44486 return NULL;
44487 }
44488
44489
44490 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44491 PyObject *resultobj = 0;
44492 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44493 unsigned int arg2 ;
44494 wxString result;
44495 void *argp1 = 0 ;
44496 int res1 = 0 ;
44497 unsigned int val2 ;
44498 int ecode2 = 0 ;
44499 PyObject * obj0 = 0 ;
44500 PyObject * obj1 = 0 ;
44501 char * kwnames[] = {
44502 (char *) "self",(char *) "n", NULL
44503 };
44504
44505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44507 if (!SWIG_IsOK(res1)) {
44508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44509 }
44510 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44511 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44512 if (!SWIG_IsOK(ecode2)) {
44513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44514 }
44515 arg2 = static_cast< unsigned int >(val2);
44516 {
44517 PyThreadState* __tstate = wxPyBeginAllowThreads();
44518 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44519 wxPyEndAllowThreads(__tstate);
44520 if (PyErr_Occurred()) SWIG_fail;
44521 }
44522 {
44523 #if wxUSE_UNICODE
44524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44525 #else
44526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44527 #endif
44528 }
44529 return resultobj;
44530 fail:
44531 return NULL;
44532 }
44533
44534
44535 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44536 PyObject *resultobj = 0;
44537 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44538 wxArrayString result;
44539 void *argp1 = 0 ;
44540 int res1 = 0 ;
44541 PyObject *swig_obj[1] ;
44542
44543 if (!args) SWIG_fail;
44544 swig_obj[0] = args;
44545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44546 if (!SWIG_IsOK(res1)) {
44547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44548 }
44549 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44550 {
44551 PyThreadState* __tstate = wxPyBeginAllowThreads();
44552 result = ((wxItemContainer const *)arg1)->GetStrings();
44553 wxPyEndAllowThreads(__tstate);
44554 if (PyErr_Occurred()) SWIG_fail;
44555 }
44556 {
44557 resultobj = wxArrayString2PyList_helper(result);
44558 }
44559 return resultobj;
44560 fail:
44561 return NULL;
44562 }
44563
44564
44565 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44566 PyObject *resultobj = 0;
44567 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44568 unsigned int arg2 ;
44569 wxString *arg3 = 0 ;
44570 void *argp1 = 0 ;
44571 int res1 = 0 ;
44572 unsigned int val2 ;
44573 int ecode2 = 0 ;
44574 bool temp3 = false ;
44575 PyObject * obj0 = 0 ;
44576 PyObject * obj1 = 0 ;
44577 PyObject * obj2 = 0 ;
44578 char * kwnames[] = {
44579 (char *) "self",(char *) "n",(char *) "s", NULL
44580 };
44581
44582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44584 if (!SWIG_IsOK(res1)) {
44585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44586 }
44587 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44588 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44589 if (!SWIG_IsOK(ecode2)) {
44590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44591 }
44592 arg2 = static_cast< unsigned int >(val2);
44593 {
44594 arg3 = wxString_in_helper(obj2);
44595 if (arg3 == NULL) SWIG_fail;
44596 temp3 = true;
44597 }
44598 {
44599 PyThreadState* __tstate = wxPyBeginAllowThreads();
44600 (arg1)->SetString(arg2,(wxString const &)*arg3);
44601 wxPyEndAllowThreads(__tstate);
44602 if (PyErr_Occurred()) SWIG_fail;
44603 }
44604 resultobj = SWIG_Py_Void();
44605 {
44606 if (temp3)
44607 delete arg3;
44608 }
44609 return resultobj;
44610 fail:
44611 {
44612 if (temp3)
44613 delete arg3;
44614 }
44615 return NULL;
44616 }
44617
44618
44619 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44620 PyObject *resultobj = 0;
44621 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44622 wxString *arg2 = 0 ;
44623 int result;
44624 void *argp1 = 0 ;
44625 int res1 = 0 ;
44626 bool temp2 = false ;
44627 PyObject * obj0 = 0 ;
44628 PyObject * obj1 = 0 ;
44629 char * kwnames[] = {
44630 (char *) "self",(char *) "s", NULL
44631 };
44632
44633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44635 if (!SWIG_IsOK(res1)) {
44636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44637 }
44638 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44639 {
44640 arg2 = wxString_in_helper(obj1);
44641 if (arg2 == NULL) SWIG_fail;
44642 temp2 = true;
44643 }
44644 {
44645 PyThreadState* __tstate = wxPyBeginAllowThreads();
44646 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44647 wxPyEndAllowThreads(__tstate);
44648 if (PyErr_Occurred()) SWIG_fail;
44649 }
44650 resultobj = SWIG_From_int(static_cast< int >(result));
44651 {
44652 if (temp2)
44653 delete arg2;
44654 }
44655 return resultobj;
44656 fail:
44657 {
44658 if (temp2)
44659 delete arg2;
44660 }
44661 return NULL;
44662 }
44663
44664
44665 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44666 PyObject *resultobj = 0;
44667 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44668 int arg2 ;
44669 void *argp1 = 0 ;
44670 int res1 = 0 ;
44671 int val2 ;
44672 int ecode2 = 0 ;
44673 PyObject * obj0 = 0 ;
44674 PyObject * obj1 = 0 ;
44675 char * kwnames[] = {
44676 (char *) "self",(char *) "n", NULL
44677 };
44678
44679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44681 if (!SWIG_IsOK(res1)) {
44682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44683 }
44684 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44685 ecode2 = SWIG_AsVal_int(obj1, &val2);
44686 if (!SWIG_IsOK(ecode2)) {
44687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44688 }
44689 arg2 = static_cast< int >(val2);
44690 {
44691 PyThreadState* __tstate = wxPyBeginAllowThreads();
44692 (arg1)->SetSelection(arg2);
44693 wxPyEndAllowThreads(__tstate);
44694 if (PyErr_Occurred()) SWIG_fail;
44695 }
44696 resultobj = SWIG_Py_Void();
44697 return resultobj;
44698 fail:
44699 return NULL;
44700 }
44701
44702
44703 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44704 PyObject *resultobj = 0;
44705 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44706 int result;
44707 void *argp1 = 0 ;
44708 int res1 = 0 ;
44709 PyObject *swig_obj[1] ;
44710
44711 if (!args) SWIG_fail;
44712 swig_obj[0] = args;
44713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44714 if (!SWIG_IsOK(res1)) {
44715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44716 }
44717 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44718 {
44719 PyThreadState* __tstate = wxPyBeginAllowThreads();
44720 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44721 wxPyEndAllowThreads(__tstate);
44722 if (PyErr_Occurred()) SWIG_fail;
44723 }
44724 resultobj = SWIG_From_int(static_cast< int >(result));
44725 return resultobj;
44726 fail:
44727 return NULL;
44728 }
44729
44730
44731 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44732 PyObject *resultobj = 0;
44733 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44734 wxString *arg2 = 0 ;
44735 bool result;
44736 void *argp1 = 0 ;
44737 int res1 = 0 ;
44738 bool temp2 = false ;
44739 PyObject * obj0 = 0 ;
44740 PyObject * obj1 = 0 ;
44741 char * kwnames[] = {
44742 (char *) "self",(char *) "s", NULL
44743 };
44744
44745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44747 if (!SWIG_IsOK(res1)) {
44748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44749 }
44750 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44751 {
44752 arg2 = wxString_in_helper(obj1);
44753 if (arg2 == NULL) SWIG_fail;
44754 temp2 = true;
44755 }
44756 {
44757 PyThreadState* __tstate = wxPyBeginAllowThreads();
44758 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44759 wxPyEndAllowThreads(__tstate);
44760 if (PyErr_Occurred()) SWIG_fail;
44761 }
44762 {
44763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44764 }
44765 {
44766 if (temp2)
44767 delete arg2;
44768 }
44769 return resultobj;
44770 fail:
44771 {
44772 if (temp2)
44773 delete arg2;
44774 }
44775 return NULL;
44776 }
44777
44778
44779 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44780 PyObject *resultobj = 0;
44781 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44782 wxString result;
44783 void *argp1 = 0 ;
44784 int res1 = 0 ;
44785 PyObject *swig_obj[1] ;
44786
44787 if (!args) SWIG_fail;
44788 swig_obj[0] = args;
44789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44790 if (!SWIG_IsOK(res1)) {
44791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44792 }
44793 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44794 {
44795 PyThreadState* __tstate = wxPyBeginAllowThreads();
44796 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44797 wxPyEndAllowThreads(__tstate);
44798 if (PyErr_Occurred()) SWIG_fail;
44799 }
44800 {
44801 #if wxUSE_UNICODE
44802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44803 #else
44804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44805 #endif
44806 }
44807 return resultobj;
44808 fail:
44809 return NULL;
44810 }
44811
44812
44813 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44814 PyObject *resultobj = 0;
44815 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44816 int arg2 ;
44817 void *argp1 = 0 ;
44818 int res1 = 0 ;
44819 int val2 ;
44820 int ecode2 = 0 ;
44821 PyObject * obj0 = 0 ;
44822 PyObject * obj1 = 0 ;
44823 char * kwnames[] = {
44824 (char *) "self",(char *) "n", NULL
44825 };
44826
44827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44829 if (!SWIG_IsOK(res1)) {
44830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44831 }
44832 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44833 ecode2 = SWIG_AsVal_int(obj1, &val2);
44834 if (!SWIG_IsOK(ecode2)) {
44835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44836 }
44837 arg2 = static_cast< int >(val2);
44838 {
44839 PyThreadState* __tstate = wxPyBeginAllowThreads();
44840 (arg1)->Select(arg2);
44841 wxPyEndAllowThreads(__tstate);
44842 if (PyErr_Occurred()) SWIG_fail;
44843 }
44844 resultobj = SWIG_Py_Void();
44845 return resultobj;
44846 fail:
44847 return NULL;
44848 }
44849
44850
44851 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44852 PyObject *obj;
44853 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44854 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44855 return SWIG_Py_Void();
44856 }
44857
44858 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44859 PyObject *obj;
44860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44861 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44862 return SWIG_Py_Void();
44863 }
44864
44865 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44866 PyObject *resultobj = 0;
44867 wxSizerItem *result = 0 ;
44868
44869 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44870 {
44871 PyThreadState* __tstate = wxPyBeginAllowThreads();
44872 result = (wxSizerItem *)new wxSizerItem();
44873 wxPyEndAllowThreads(__tstate);
44874 if (PyErr_Occurred()) SWIG_fail;
44875 }
44876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44877 return resultobj;
44878 fail:
44879 return NULL;
44880 }
44881
44882
44883 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44884 PyObject *resultobj = 0;
44885 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44886 void *argp1 = 0 ;
44887 int res1 = 0 ;
44888 PyObject *swig_obj[1] ;
44889
44890 if (!args) SWIG_fail;
44891 swig_obj[0] = args;
44892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44893 if (!SWIG_IsOK(res1)) {
44894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44895 }
44896 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44897 {
44898 PyThreadState* __tstate = wxPyBeginAllowThreads();
44899 delete arg1;
44900
44901 wxPyEndAllowThreads(__tstate);
44902 if (PyErr_Occurred()) SWIG_fail;
44903 }
44904 resultobj = SWIG_Py_Void();
44905 return resultobj;
44906 fail:
44907 return NULL;
44908 }
44909
44910
44911 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44912 PyObject *resultobj = 0;
44913 wxWindow *arg1 = (wxWindow *) 0 ;
44914 int arg2 ;
44915 int arg3 ;
44916 int arg4 ;
44917 PyObject *arg5 = (PyObject *) NULL ;
44918 wxSizerItem *result = 0 ;
44919 void *argp1 = 0 ;
44920 int res1 = 0 ;
44921 int val2 ;
44922 int ecode2 = 0 ;
44923 int val3 ;
44924 int ecode3 = 0 ;
44925 int val4 ;
44926 int ecode4 = 0 ;
44927 PyObject * obj0 = 0 ;
44928 PyObject * obj1 = 0 ;
44929 PyObject * obj2 = 0 ;
44930 PyObject * obj3 = 0 ;
44931 PyObject * obj4 = 0 ;
44932 char * kwnames[] = {
44933 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44934 };
44935
44936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44938 if (!SWIG_IsOK(res1)) {
44939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44940 }
44941 arg1 = reinterpret_cast< wxWindow * >(argp1);
44942 ecode2 = SWIG_AsVal_int(obj1, &val2);
44943 if (!SWIG_IsOK(ecode2)) {
44944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44945 }
44946 arg2 = static_cast< int >(val2);
44947 ecode3 = SWIG_AsVal_int(obj2, &val3);
44948 if (!SWIG_IsOK(ecode3)) {
44949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44950 }
44951 arg3 = static_cast< int >(val3);
44952 ecode4 = SWIG_AsVal_int(obj3, &val4);
44953 if (!SWIG_IsOK(ecode4)) {
44954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44955 }
44956 arg4 = static_cast< int >(val4);
44957 if (obj4) {
44958 arg5 = obj4;
44959 }
44960 {
44961 PyThreadState* __tstate = wxPyBeginAllowThreads();
44962 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44963 wxPyEndAllowThreads(__tstate);
44964 if (PyErr_Occurred()) SWIG_fail;
44965 }
44966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44967 return resultobj;
44968 fail:
44969 return NULL;
44970 }
44971
44972
44973 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44974 PyObject *resultobj = 0;
44975 int arg1 ;
44976 int arg2 ;
44977 int arg3 ;
44978 int arg4 ;
44979 int arg5 ;
44980 PyObject *arg6 = (PyObject *) NULL ;
44981 wxSizerItem *result = 0 ;
44982 int val1 ;
44983 int ecode1 = 0 ;
44984 int val2 ;
44985 int ecode2 = 0 ;
44986 int val3 ;
44987 int ecode3 = 0 ;
44988 int val4 ;
44989 int ecode4 = 0 ;
44990 int val5 ;
44991 int ecode5 = 0 ;
44992 PyObject * obj0 = 0 ;
44993 PyObject * obj1 = 0 ;
44994 PyObject * obj2 = 0 ;
44995 PyObject * obj3 = 0 ;
44996 PyObject * obj4 = 0 ;
44997 PyObject * obj5 = 0 ;
44998 char * kwnames[] = {
44999 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45000 };
45001
45002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45003 ecode1 = SWIG_AsVal_int(obj0, &val1);
45004 if (!SWIG_IsOK(ecode1)) {
45005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45006 }
45007 arg1 = static_cast< int >(val1);
45008 ecode2 = SWIG_AsVal_int(obj1, &val2);
45009 if (!SWIG_IsOK(ecode2)) {
45010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45011 }
45012 arg2 = static_cast< int >(val2);
45013 ecode3 = SWIG_AsVal_int(obj2, &val3);
45014 if (!SWIG_IsOK(ecode3)) {
45015 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45016 }
45017 arg3 = static_cast< int >(val3);
45018 ecode4 = SWIG_AsVal_int(obj3, &val4);
45019 if (!SWIG_IsOK(ecode4)) {
45020 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45021 }
45022 arg4 = static_cast< int >(val4);
45023 ecode5 = SWIG_AsVal_int(obj4, &val5);
45024 if (!SWIG_IsOK(ecode5)) {
45025 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45026 }
45027 arg5 = static_cast< int >(val5);
45028 if (obj5) {
45029 arg6 = obj5;
45030 }
45031 {
45032 PyThreadState* __tstate = wxPyBeginAllowThreads();
45033 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45034 wxPyEndAllowThreads(__tstate);
45035 if (PyErr_Occurred()) SWIG_fail;
45036 }
45037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45038 return resultobj;
45039 fail:
45040 return NULL;
45041 }
45042
45043
45044 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45045 PyObject *resultobj = 0;
45046 wxSizer *arg1 = (wxSizer *) 0 ;
45047 int arg2 ;
45048 int arg3 ;
45049 int arg4 ;
45050 PyObject *arg5 = (PyObject *) NULL ;
45051 wxSizerItem *result = 0 ;
45052 int res1 = 0 ;
45053 int val2 ;
45054 int ecode2 = 0 ;
45055 int val3 ;
45056 int ecode3 = 0 ;
45057 int val4 ;
45058 int ecode4 = 0 ;
45059 PyObject * obj0 = 0 ;
45060 PyObject * obj1 = 0 ;
45061 PyObject * obj2 = 0 ;
45062 PyObject * obj3 = 0 ;
45063 PyObject * obj4 = 0 ;
45064 char * kwnames[] = {
45065 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45066 };
45067
45068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45069 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45070 if (!SWIG_IsOK(res1)) {
45071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45072 }
45073 ecode2 = SWIG_AsVal_int(obj1, &val2);
45074 if (!SWIG_IsOK(ecode2)) {
45075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45076 }
45077 arg2 = static_cast< int >(val2);
45078 ecode3 = SWIG_AsVal_int(obj2, &val3);
45079 if (!SWIG_IsOK(ecode3)) {
45080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45081 }
45082 arg3 = static_cast< int >(val3);
45083 ecode4 = SWIG_AsVal_int(obj3, &val4);
45084 if (!SWIG_IsOK(ecode4)) {
45085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45086 }
45087 arg4 = static_cast< int >(val4);
45088 if (obj4) {
45089 arg5 = obj4;
45090 }
45091 {
45092 PyThreadState* __tstate = wxPyBeginAllowThreads();
45093 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45094 wxPyEndAllowThreads(__tstate);
45095 if (PyErr_Occurred()) SWIG_fail;
45096 }
45097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45098 return resultobj;
45099 fail:
45100 return NULL;
45101 }
45102
45103
45104 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45105 PyObject *resultobj = 0;
45106 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45107 void *argp1 = 0 ;
45108 int res1 = 0 ;
45109 PyObject *swig_obj[1] ;
45110
45111 if (!args) SWIG_fail;
45112 swig_obj[0] = args;
45113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45114 if (!SWIG_IsOK(res1)) {
45115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45116 }
45117 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45118 {
45119 PyThreadState* __tstate = wxPyBeginAllowThreads();
45120 (arg1)->DeleteWindows();
45121 wxPyEndAllowThreads(__tstate);
45122 if (PyErr_Occurred()) SWIG_fail;
45123 }
45124 resultobj = SWIG_Py_Void();
45125 return resultobj;
45126 fail:
45127 return NULL;
45128 }
45129
45130
45131 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45132 PyObject *resultobj = 0;
45133 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45134 void *argp1 = 0 ;
45135 int res1 = 0 ;
45136 PyObject *swig_obj[1] ;
45137
45138 if (!args) SWIG_fail;
45139 swig_obj[0] = args;
45140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45141 if (!SWIG_IsOK(res1)) {
45142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45143 }
45144 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45145 {
45146 PyThreadState* __tstate = wxPyBeginAllowThreads();
45147 (arg1)->DetachSizer();
45148 wxPyEndAllowThreads(__tstate);
45149 if (PyErr_Occurred()) SWIG_fail;
45150 }
45151 resultobj = SWIG_Py_Void();
45152 return resultobj;
45153 fail:
45154 return NULL;
45155 }
45156
45157
45158 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45159 PyObject *resultobj = 0;
45160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45161 wxSize result;
45162 void *argp1 = 0 ;
45163 int res1 = 0 ;
45164 PyObject *swig_obj[1] ;
45165
45166 if (!args) SWIG_fail;
45167 swig_obj[0] = args;
45168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45169 if (!SWIG_IsOK(res1)) {
45170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45171 }
45172 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45173 {
45174 PyThreadState* __tstate = wxPyBeginAllowThreads();
45175 result = (arg1)->GetSize();
45176 wxPyEndAllowThreads(__tstate);
45177 if (PyErr_Occurred()) SWIG_fail;
45178 }
45179 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45180 return resultobj;
45181 fail:
45182 return NULL;
45183 }
45184
45185
45186 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45187 PyObject *resultobj = 0;
45188 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45189 wxSize result;
45190 void *argp1 = 0 ;
45191 int res1 = 0 ;
45192 PyObject *swig_obj[1] ;
45193
45194 if (!args) SWIG_fail;
45195 swig_obj[0] = args;
45196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45197 if (!SWIG_IsOK(res1)) {
45198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45199 }
45200 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45201 {
45202 PyThreadState* __tstate = wxPyBeginAllowThreads();
45203 result = (arg1)->CalcMin();
45204 wxPyEndAllowThreads(__tstate);
45205 if (PyErr_Occurred()) SWIG_fail;
45206 }
45207 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45208 return resultobj;
45209 fail:
45210 return NULL;
45211 }
45212
45213
45214 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45215 PyObject *resultobj = 0;
45216 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45217 wxPoint *arg2 = 0 ;
45218 wxSize *arg3 = 0 ;
45219 void *argp1 = 0 ;
45220 int res1 = 0 ;
45221 wxPoint temp2 ;
45222 wxSize temp3 ;
45223 PyObject * obj0 = 0 ;
45224 PyObject * obj1 = 0 ;
45225 PyObject * obj2 = 0 ;
45226 char * kwnames[] = {
45227 (char *) "self",(char *) "pos",(char *) "size", NULL
45228 };
45229
45230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45232 if (!SWIG_IsOK(res1)) {
45233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45234 }
45235 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45236 {
45237 arg2 = &temp2;
45238 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45239 }
45240 {
45241 arg3 = &temp3;
45242 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45243 }
45244 {
45245 PyThreadState* __tstate = wxPyBeginAllowThreads();
45246 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45247 wxPyEndAllowThreads(__tstate);
45248 if (PyErr_Occurred()) SWIG_fail;
45249 }
45250 resultobj = SWIG_Py_Void();
45251 return resultobj;
45252 fail:
45253 return NULL;
45254 }
45255
45256
45257 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45258 PyObject *resultobj = 0;
45259 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45260 wxSize result;
45261 void *argp1 = 0 ;
45262 int res1 = 0 ;
45263 PyObject *swig_obj[1] ;
45264
45265 if (!args) SWIG_fail;
45266 swig_obj[0] = args;
45267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45268 if (!SWIG_IsOK(res1)) {
45269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45270 }
45271 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45272 {
45273 PyThreadState* __tstate = wxPyBeginAllowThreads();
45274 result = (arg1)->GetMinSize();
45275 wxPyEndAllowThreads(__tstate);
45276 if (PyErr_Occurred()) SWIG_fail;
45277 }
45278 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45279 return resultobj;
45280 fail:
45281 return NULL;
45282 }
45283
45284
45285 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45286 PyObject *resultobj = 0;
45287 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45288 wxSize result;
45289 void *argp1 = 0 ;
45290 int res1 = 0 ;
45291 PyObject *swig_obj[1] ;
45292
45293 if (!args) SWIG_fail;
45294 swig_obj[0] = args;
45295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45296 if (!SWIG_IsOK(res1)) {
45297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45298 }
45299 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45300 {
45301 PyThreadState* __tstate = wxPyBeginAllowThreads();
45302 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45303 wxPyEndAllowThreads(__tstate);
45304 if (PyErr_Occurred()) SWIG_fail;
45305 }
45306 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45307 return resultobj;
45308 fail:
45309 return NULL;
45310 }
45311
45312
45313 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45314 PyObject *resultobj = 0;
45315 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45316 int arg2 ;
45317 int arg3 ;
45318 void *argp1 = 0 ;
45319 int res1 = 0 ;
45320 int val2 ;
45321 int ecode2 = 0 ;
45322 int val3 ;
45323 int ecode3 = 0 ;
45324 PyObject * obj0 = 0 ;
45325 PyObject * obj1 = 0 ;
45326 PyObject * obj2 = 0 ;
45327 char * kwnames[] = {
45328 (char *) "self",(char *) "x",(char *) "y", NULL
45329 };
45330
45331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45333 if (!SWIG_IsOK(res1)) {
45334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45335 }
45336 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45337 ecode2 = SWIG_AsVal_int(obj1, &val2);
45338 if (!SWIG_IsOK(ecode2)) {
45339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45340 }
45341 arg2 = static_cast< int >(val2);
45342 ecode3 = SWIG_AsVal_int(obj2, &val3);
45343 if (!SWIG_IsOK(ecode3)) {
45344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45345 }
45346 arg3 = static_cast< int >(val3);
45347 {
45348 PyThreadState* __tstate = wxPyBeginAllowThreads();
45349 (arg1)->SetInitSize(arg2,arg3);
45350 wxPyEndAllowThreads(__tstate);
45351 if (PyErr_Occurred()) SWIG_fail;
45352 }
45353 resultobj = SWIG_Py_Void();
45354 return resultobj;
45355 fail:
45356 return NULL;
45357 }
45358
45359
45360 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45361 PyObject *resultobj = 0;
45362 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45363 int arg2 ;
45364 int arg3 ;
45365 void *argp1 = 0 ;
45366 int res1 = 0 ;
45367 int val2 ;
45368 int ecode2 = 0 ;
45369 int val3 ;
45370 int ecode3 = 0 ;
45371 PyObject * obj0 = 0 ;
45372 PyObject * obj1 = 0 ;
45373 PyObject * obj2 = 0 ;
45374 char * kwnames[] = {
45375 (char *) "self",(char *) "width",(char *) "height", NULL
45376 };
45377
45378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45380 if (!SWIG_IsOK(res1)) {
45381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45382 }
45383 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45384 ecode2 = SWIG_AsVal_int(obj1, &val2);
45385 if (!SWIG_IsOK(ecode2)) {
45386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45387 }
45388 arg2 = static_cast< int >(val2);
45389 ecode3 = SWIG_AsVal_int(obj2, &val3);
45390 if (!SWIG_IsOK(ecode3)) {
45391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45392 }
45393 arg3 = static_cast< int >(val3);
45394 {
45395 PyThreadState* __tstate = wxPyBeginAllowThreads();
45396 (arg1)->SetRatio(arg2,arg3);
45397 wxPyEndAllowThreads(__tstate);
45398 if (PyErr_Occurred()) SWIG_fail;
45399 }
45400 resultobj = SWIG_Py_Void();
45401 return resultobj;
45402 fail:
45403 return NULL;
45404 }
45405
45406
45407 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45408 PyObject *resultobj = 0;
45409 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45410 wxSize *arg2 = 0 ;
45411 void *argp1 = 0 ;
45412 int res1 = 0 ;
45413 wxSize temp2 ;
45414 PyObject * obj0 = 0 ;
45415 PyObject * obj1 = 0 ;
45416 char * kwnames[] = {
45417 (char *) "self",(char *) "size", NULL
45418 };
45419
45420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45422 if (!SWIG_IsOK(res1)) {
45423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45424 }
45425 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45426 {
45427 arg2 = &temp2;
45428 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45429 }
45430 {
45431 PyThreadState* __tstate = wxPyBeginAllowThreads();
45432 (arg1)->SetRatio((wxSize const &)*arg2);
45433 wxPyEndAllowThreads(__tstate);
45434 if (PyErr_Occurred()) SWIG_fail;
45435 }
45436 resultobj = SWIG_Py_Void();
45437 return resultobj;
45438 fail:
45439 return NULL;
45440 }
45441
45442
45443 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45444 PyObject *resultobj = 0;
45445 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45446 float arg2 ;
45447 void *argp1 = 0 ;
45448 int res1 = 0 ;
45449 float val2 ;
45450 int ecode2 = 0 ;
45451 PyObject * obj0 = 0 ;
45452 PyObject * obj1 = 0 ;
45453 char * kwnames[] = {
45454 (char *) "self",(char *) "ratio", NULL
45455 };
45456
45457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45459 if (!SWIG_IsOK(res1)) {
45460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45461 }
45462 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45463 ecode2 = SWIG_AsVal_float(obj1, &val2);
45464 if (!SWIG_IsOK(ecode2)) {
45465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45466 }
45467 arg2 = static_cast< float >(val2);
45468 {
45469 PyThreadState* __tstate = wxPyBeginAllowThreads();
45470 (arg1)->SetRatio(arg2);
45471 wxPyEndAllowThreads(__tstate);
45472 if (PyErr_Occurred()) SWIG_fail;
45473 }
45474 resultobj = SWIG_Py_Void();
45475 return resultobj;
45476 fail:
45477 return NULL;
45478 }
45479
45480
45481 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45482 PyObject *resultobj = 0;
45483 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45484 float result;
45485 void *argp1 = 0 ;
45486 int res1 = 0 ;
45487 PyObject *swig_obj[1] ;
45488
45489 if (!args) SWIG_fail;
45490 swig_obj[0] = args;
45491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45492 if (!SWIG_IsOK(res1)) {
45493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45494 }
45495 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45496 {
45497 PyThreadState* __tstate = wxPyBeginAllowThreads();
45498 result = (float)(arg1)->GetRatio();
45499 wxPyEndAllowThreads(__tstate);
45500 if (PyErr_Occurred()) SWIG_fail;
45501 }
45502 resultobj = SWIG_From_float(static_cast< float >(result));
45503 return resultobj;
45504 fail:
45505 return NULL;
45506 }
45507
45508
45509 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45510 PyObject *resultobj = 0;
45511 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45512 wxRect result;
45513 void *argp1 = 0 ;
45514 int res1 = 0 ;
45515 PyObject *swig_obj[1] ;
45516
45517 if (!args) SWIG_fail;
45518 swig_obj[0] = args;
45519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45520 if (!SWIG_IsOK(res1)) {
45521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45522 }
45523 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45524 {
45525 PyThreadState* __tstate = wxPyBeginAllowThreads();
45526 result = (arg1)->GetRect();
45527 wxPyEndAllowThreads(__tstate);
45528 if (PyErr_Occurred()) SWIG_fail;
45529 }
45530 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45531 return resultobj;
45532 fail:
45533 return NULL;
45534 }
45535
45536
45537 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45538 PyObject *resultobj = 0;
45539 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45540 bool result;
45541 void *argp1 = 0 ;
45542 int res1 = 0 ;
45543 PyObject *swig_obj[1] ;
45544
45545 if (!args) SWIG_fail;
45546 swig_obj[0] = args;
45547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45548 if (!SWIG_IsOK(res1)) {
45549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45550 }
45551 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45552 {
45553 PyThreadState* __tstate = wxPyBeginAllowThreads();
45554 result = (bool)(arg1)->IsWindow();
45555 wxPyEndAllowThreads(__tstate);
45556 if (PyErr_Occurred()) SWIG_fail;
45557 }
45558 {
45559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45560 }
45561 return resultobj;
45562 fail:
45563 return NULL;
45564 }
45565
45566
45567 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45568 PyObject *resultobj = 0;
45569 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45570 bool result;
45571 void *argp1 = 0 ;
45572 int res1 = 0 ;
45573 PyObject *swig_obj[1] ;
45574
45575 if (!args) SWIG_fail;
45576 swig_obj[0] = args;
45577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45578 if (!SWIG_IsOK(res1)) {
45579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45580 }
45581 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45582 {
45583 PyThreadState* __tstate = wxPyBeginAllowThreads();
45584 result = (bool)(arg1)->IsSizer();
45585 wxPyEndAllowThreads(__tstate);
45586 if (PyErr_Occurred()) SWIG_fail;
45587 }
45588 {
45589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45590 }
45591 return resultobj;
45592 fail:
45593 return NULL;
45594 }
45595
45596
45597 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45598 PyObject *resultobj = 0;
45599 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45600 bool result;
45601 void *argp1 = 0 ;
45602 int res1 = 0 ;
45603 PyObject *swig_obj[1] ;
45604
45605 if (!args) SWIG_fail;
45606 swig_obj[0] = args;
45607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45608 if (!SWIG_IsOK(res1)) {
45609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45610 }
45611 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45612 {
45613 PyThreadState* __tstate = wxPyBeginAllowThreads();
45614 result = (bool)(arg1)->IsSpacer();
45615 wxPyEndAllowThreads(__tstate);
45616 if (PyErr_Occurred()) SWIG_fail;
45617 }
45618 {
45619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45620 }
45621 return resultobj;
45622 fail:
45623 return NULL;
45624 }
45625
45626
45627 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45628 PyObject *resultobj = 0;
45629 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45630 int arg2 ;
45631 void *argp1 = 0 ;
45632 int res1 = 0 ;
45633 int val2 ;
45634 int ecode2 = 0 ;
45635 PyObject * obj0 = 0 ;
45636 PyObject * obj1 = 0 ;
45637 char * kwnames[] = {
45638 (char *) "self",(char *) "proportion", NULL
45639 };
45640
45641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45643 if (!SWIG_IsOK(res1)) {
45644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45645 }
45646 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45647 ecode2 = SWIG_AsVal_int(obj1, &val2);
45648 if (!SWIG_IsOK(ecode2)) {
45649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45650 }
45651 arg2 = static_cast< int >(val2);
45652 {
45653 PyThreadState* __tstate = wxPyBeginAllowThreads();
45654 (arg1)->SetProportion(arg2);
45655 wxPyEndAllowThreads(__tstate);
45656 if (PyErr_Occurred()) SWIG_fail;
45657 }
45658 resultobj = SWIG_Py_Void();
45659 return resultobj;
45660 fail:
45661 return NULL;
45662 }
45663
45664
45665 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45666 PyObject *resultobj = 0;
45667 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45668 int result;
45669 void *argp1 = 0 ;
45670 int res1 = 0 ;
45671 PyObject *swig_obj[1] ;
45672
45673 if (!args) SWIG_fail;
45674 swig_obj[0] = args;
45675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45676 if (!SWIG_IsOK(res1)) {
45677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45678 }
45679 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45680 {
45681 PyThreadState* __tstate = wxPyBeginAllowThreads();
45682 result = (int)(arg1)->GetProportion();
45683 wxPyEndAllowThreads(__tstate);
45684 if (PyErr_Occurred()) SWIG_fail;
45685 }
45686 resultobj = SWIG_From_int(static_cast< int >(result));
45687 return resultobj;
45688 fail:
45689 return NULL;
45690 }
45691
45692
45693 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45694 PyObject *resultobj = 0;
45695 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45696 int arg2 ;
45697 void *argp1 = 0 ;
45698 int res1 = 0 ;
45699 int val2 ;
45700 int ecode2 = 0 ;
45701 PyObject * obj0 = 0 ;
45702 PyObject * obj1 = 0 ;
45703 char * kwnames[] = {
45704 (char *) "self",(char *) "flag", NULL
45705 };
45706
45707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45709 if (!SWIG_IsOK(res1)) {
45710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45711 }
45712 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45713 ecode2 = SWIG_AsVal_int(obj1, &val2);
45714 if (!SWIG_IsOK(ecode2)) {
45715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45716 }
45717 arg2 = static_cast< int >(val2);
45718 {
45719 PyThreadState* __tstate = wxPyBeginAllowThreads();
45720 (arg1)->SetFlag(arg2);
45721 wxPyEndAllowThreads(__tstate);
45722 if (PyErr_Occurred()) SWIG_fail;
45723 }
45724 resultobj = SWIG_Py_Void();
45725 return resultobj;
45726 fail:
45727 return NULL;
45728 }
45729
45730
45731 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45732 PyObject *resultobj = 0;
45733 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45734 int result;
45735 void *argp1 = 0 ;
45736 int res1 = 0 ;
45737 PyObject *swig_obj[1] ;
45738
45739 if (!args) SWIG_fail;
45740 swig_obj[0] = args;
45741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45742 if (!SWIG_IsOK(res1)) {
45743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45744 }
45745 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45746 {
45747 PyThreadState* __tstate = wxPyBeginAllowThreads();
45748 result = (int)(arg1)->GetFlag();
45749 wxPyEndAllowThreads(__tstate);
45750 if (PyErr_Occurred()) SWIG_fail;
45751 }
45752 resultobj = SWIG_From_int(static_cast< int >(result));
45753 return resultobj;
45754 fail:
45755 return NULL;
45756 }
45757
45758
45759 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45760 PyObject *resultobj = 0;
45761 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45762 int arg2 ;
45763 void *argp1 = 0 ;
45764 int res1 = 0 ;
45765 int val2 ;
45766 int ecode2 = 0 ;
45767 PyObject * obj0 = 0 ;
45768 PyObject * obj1 = 0 ;
45769 char * kwnames[] = {
45770 (char *) "self",(char *) "border", NULL
45771 };
45772
45773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45775 if (!SWIG_IsOK(res1)) {
45776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45777 }
45778 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45779 ecode2 = SWIG_AsVal_int(obj1, &val2);
45780 if (!SWIG_IsOK(ecode2)) {
45781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45782 }
45783 arg2 = static_cast< int >(val2);
45784 {
45785 PyThreadState* __tstate = wxPyBeginAllowThreads();
45786 (arg1)->SetBorder(arg2);
45787 wxPyEndAllowThreads(__tstate);
45788 if (PyErr_Occurred()) SWIG_fail;
45789 }
45790 resultobj = SWIG_Py_Void();
45791 return resultobj;
45792 fail:
45793 return NULL;
45794 }
45795
45796
45797 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45798 PyObject *resultobj = 0;
45799 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45800 int result;
45801 void *argp1 = 0 ;
45802 int res1 = 0 ;
45803 PyObject *swig_obj[1] ;
45804
45805 if (!args) SWIG_fail;
45806 swig_obj[0] = args;
45807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45808 if (!SWIG_IsOK(res1)) {
45809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45810 }
45811 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45812 {
45813 PyThreadState* __tstate = wxPyBeginAllowThreads();
45814 result = (int)(arg1)->GetBorder();
45815 wxPyEndAllowThreads(__tstate);
45816 if (PyErr_Occurred()) SWIG_fail;
45817 }
45818 resultobj = SWIG_From_int(static_cast< int >(result));
45819 return resultobj;
45820 fail:
45821 return NULL;
45822 }
45823
45824
45825 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45826 PyObject *resultobj = 0;
45827 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45828 wxWindow *result = 0 ;
45829 void *argp1 = 0 ;
45830 int res1 = 0 ;
45831 PyObject *swig_obj[1] ;
45832
45833 if (!args) SWIG_fail;
45834 swig_obj[0] = args;
45835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45836 if (!SWIG_IsOK(res1)) {
45837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45838 }
45839 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45840 {
45841 PyThreadState* __tstate = wxPyBeginAllowThreads();
45842 result = (wxWindow *)(arg1)->GetWindow();
45843 wxPyEndAllowThreads(__tstate);
45844 if (PyErr_Occurred()) SWIG_fail;
45845 }
45846 {
45847 resultobj = wxPyMake_wxObject(result, 0);
45848 }
45849 return resultobj;
45850 fail:
45851 return NULL;
45852 }
45853
45854
45855 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45856 PyObject *resultobj = 0;
45857 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45858 wxWindow *arg2 = (wxWindow *) 0 ;
45859 void *argp1 = 0 ;
45860 int res1 = 0 ;
45861 void *argp2 = 0 ;
45862 int res2 = 0 ;
45863 PyObject * obj0 = 0 ;
45864 PyObject * obj1 = 0 ;
45865 char * kwnames[] = {
45866 (char *) "self",(char *) "window", NULL
45867 };
45868
45869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45871 if (!SWIG_IsOK(res1)) {
45872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45873 }
45874 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45876 if (!SWIG_IsOK(res2)) {
45877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45878 }
45879 arg2 = reinterpret_cast< wxWindow * >(argp2);
45880 {
45881 PyThreadState* __tstate = wxPyBeginAllowThreads();
45882 (arg1)->SetWindow(arg2);
45883 wxPyEndAllowThreads(__tstate);
45884 if (PyErr_Occurred()) SWIG_fail;
45885 }
45886 resultobj = SWIG_Py_Void();
45887 return resultobj;
45888 fail:
45889 return NULL;
45890 }
45891
45892
45893 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45894 PyObject *resultobj = 0;
45895 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45896 wxSizer *result = 0 ;
45897 void *argp1 = 0 ;
45898 int res1 = 0 ;
45899 PyObject *swig_obj[1] ;
45900
45901 if (!args) SWIG_fail;
45902 swig_obj[0] = args;
45903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45904 if (!SWIG_IsOK(res1)) {
45905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45906 }
45907 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45908 {
45909 PyThreadState* __tstate = wxPyBeginAllowThreads();
45910 result = (wxSizer *)(arg1)->GetSizer();
45911 wxPyEndAllowThreads(__tstate);
45912 if (PyErr_Occurred()) SWIG_fail;
45913 }
45914 {
45915 resultobj = wxPyMake_wxObject(result, (bool)0);
45916 }
45917 return resultobj;
45918 fail:
45919 return NULL;
45920 }
45921
45922
45923 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45924 PyObject *resultobj = 0;
45925 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45926 wxSizer *arg2 = (wxSizer *) 0 ;
45927 void *argp1 = 0 ;
45928 int res1 = 0 ;
45929 int res2 = 0 ;
45930 PyObject * obj0 = 0 ;
45931 PyObject * obj1 = 0 ;
45932 char * kwnames[] = {
45933 (char *) "self",(char *) "sizer", NULL
45934 };
45935
45936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45938 if (!SWIG_IsOK(res1)) {
45939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45940 }
45941 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45942 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45943 if (!SWIG_IsOK(res2)) {
45944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45945 }
45946 {
45947 PyThreadState* __tstate = wxPyBeginAllowThreads();
45948 (arg1)->SetSizer(arg2);
45949 wxPyEndAllowThreads(__tstate);
45950 if (PyErr_Occurred()) SWIG_fail;
45951 }
45952 resultobj = SWIG_Py_Void();
45953 return resultobj;
45954 fail:
45955 return NULL;
45956 }
45957
45958
45959 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45960 PyObject *resultobj = 0;
45961 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45962 wxSize *result = 0 ;
45963 void *argp1 = 0 ;
45964 int res1 = 0 ;
45965 PyObject *swig_obj[1] ;
45966
45967 if (!args) SWIG_fail;
45968 swig_obj[0] = args;
45969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45970 if (!SWIG_IsOK(res1)) {
45971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45972 }
45973 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45974 {
45975 PyThreadState* __tstate = wxPyBeginAllowThreads();
45976 {
45977 wxSize const &_result_ref = (arg1)->GetSpacer();
45978 result = (wxSize *) &_result_ref;
45979 }
45980 wxPyEndAllowThreads(__tstate);
45981 if (PyErr_Occurred()) SWIG_fail;
45982 }
45983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45984 return resultobj;
45985 fail:
45986 return NULL;
45987 }
45988
45989
45990 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45991 PyObject *resultobj = 0;
45992 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45993 wxSize *arg2 = 0 ;
45994 void *argp1 = 0 ;
45995 int res1 = 0 ;
45996 wxSize temp2 ;
45997 PyObject * obj0 = 0 ;
45998 PyObject * obj1 = 0 ;
45999 char * kwnames[] = {
46000 (char *) "self",(char *) "size", NULL
46001 };
46002
46003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46005 if (!SWIG_IsOK(res1)) {
46006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46007 }
46008 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46009 {
46010 arg2 = &temp2;
46011 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46012 }
46013 {
46014 PyThreadState* __tstate = wxPyBeginAllowThreads();
46015 (arg1)->SetSpacer((wxSize const &)*arg2);
46016 wxPyEndAllowThreads(__tstate);
46017 if (PyErr_Occurred()) SWIG_fail;
46018 }
46019 resultobj = SWIG_Py_Void();
46020 return resultobj;
46021 fail:
46022 return NULL;
46023 }
46024
46025
46026 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46027 PyObject *resultobj = 0;
46028 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46029 bool arg2 ;
46030 void *argp1 = 0 ;
46031 int res1 = 0 ;
46032 bool val2 ;
46033 int ecode2 = 0 ;
46034 PyObject * obj0 = 0 ;
46035 PyObject * obj1 = 0 ;
46036 char * kwnames[] = {
46037 (char *) "self",(char *) "show", NULL
46038 };
46039
46040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46042 if (!SWIG_IsOK(res1)) {
46043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46044 }
46045 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46046 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46047 if (!SWIG_IsOK(ecode2)) {
46048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46049 }
46050 arg2 = static_cast< bool >(val2);
46051 {
46052 PyThreadState* __tstate = wxPyBeginAllowThreads();
46053 (arg1)->Show(arg2);
46054 wxPyEndAllowThreads(__tstate);
46055 if (PyErr_Occurred()) SWIG_fail;
46056 }
46057 resultobj = SWIG_Py_Void();
46058 return resultobj;
46059 fail:
46060 return NULL;
46061 }
46062
46063
46064 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46065 PyObject *resultobj = 0;
46066 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46067 bool result;
46068 void *argp1 = 0 ;
46069 int res1 = 0 ;
46070 PyObject *swig_obj[1] ;
46071
46072 if (!args) SWIG_fail;
46073 swig_obj[0] = args;
46074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46075 if (!SWIG_IsOK(res1)) {
46076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46077 }
46078 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46079 {
46080 PyThreadState* __tstate = wxPyBeginAllowThreads();
46081 result = (bool)(arg1)->IsShown();
46082 wxPyEndAllowThreads(__tstate);
46083 if (PyErr_Occurred()) SWIG_fail;
46084 }
46085 {
46086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46087 }
46088 return resultobj;
46089 fail:
46090 return NULL;
46091 }
46092
46093
46094 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46095 PyObject *resultobj = 0;
46096 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46097 wxPoint result;
46098 void *argp1 = 0 ;
46099 int res1 = 0 ;
46100 PyObject *swig_obj[1] ;
46101
46102 if (!args) SWIG_fail;
46103 swig_obj[0] = args;
46104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46105 if (!SWIG_IsOK(res1)) {
46106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46107 }
46108 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46109 {
46110 PyThreadState* __tstate = wxPyBeginAllowThreads();
46111 result = (arg1)->GetPosition();
46112 wxPyEndAllowThreads(__tstate);
46113 if (PyErr_Occurred()) SWIG_fail;
46114 }
46115 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46116 return resultobj;
46117 fail:
46118 return NULL;
46119 }
46120
46121
46122 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46123 PyObject *resultobj = 0;
46124 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46125 PyObject *result = 0 ;
46126 void *argp1 = 0 ;
46127 int res1 = 0 ;
46128 PyObject *swig_obj[1] ;
46129
46130 if (!args) SWIG_fail;
46131 swig_obj[0] = args;
46132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46133 if (!SWIG_IsOK(res1)) {
46134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46135 }
46136 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46137 {
46138 PyThreadState* __tstate = wxPyBeginAllowThreads();
46139 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 resultobj = result;
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46153 PyObject *arg2 = (PyObject *) 0 ;
46154 void *argp1 = 0 ;
46155 int res1 = 0 ;
46156 PyObject * obj0 = 0 ;
46157 PyObject * obj1 = 0 ;
46158 char * kwnames[] = {
46159 (char *) "self",(char *) "userData", NULL
46160 };
46161
46162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46164 if (!SWIG_IsOK(res1)) {
46165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46166 }
46167 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46168 arg2 = obj1;
46169 {
46170 PyThreadState* __tstate = wxPyBeginAllowThreads();
46171 wxSizerItem_SetUserData(arg1,arg2);
46172 wxPyEndAllowThreads(__tstate);
46173 if (PyErr_Occurred()) SWIG_fail;
46174 }
46175 resultobj = SWIG_Py_Void();
46176 return resultobj;
46177 fail:
46178 return NULL;
46179 }
46180
46181
46182 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46183 PyObject *obj;
46184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46185 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46186 return SWIG_Py_Void();
46187 }
46188
46189 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46190 return SWIG_Python_InitShadowInstance(args);
46191 }
46192
46193 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46194 PyObject *resultobj = 0;
46195 wxSizer *arg1 = (wxSizer *) 0 ;
46196 void *argp1 = 0 ;
46197 int res1 = 0 ;
46198 PyObject *swig_obj[1] ;
46199
46200 if (!args) SWIG_fail;
46201 swig_obj[0] = args;
46202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46203 if (!SWIG_IsOK(res1)) {
46204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46205 }
46206 arg1 = reinterpret_cast< wxSizer * >(argp1);
46207 {
46208 PyThreadState* __tstate = wxPyBeginAllowThreads();
46209 delete arg1;
46210
46211 wxPyEndAllowThreads(__tstate);
46212 if (PyErr_Occurred()) SWIG_fail;
46213 }
46214 resultobj = SWIG_Py_Void();
46215 return resultobj;
46216 fail:
46217 return NULL;
46218 }
46219
46220
46221 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46222 PyObject *resultobj = 0;
46223 wxSizer *arg1 = (wxSizer *) 0 ;
46224 PyObject *arg2 = (PyObject *) 0 ;
46225 void *argp1 = 0 ;
46226 int res1 = 0 ;
46227 PyObject * obj0 = 0 ;
46228 PyObject * obj1 = 0 ;
46229 char * kwnames[] = {
46230 (char *) "self",(char *) "_self", NULL
46231 };
46232
46233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46235 if (!SWIG_IsOK(res1)) {
46236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46237 }
46238 arg1 = reinterpret_cast< wxSizer * >(argp1);
46239 arg2 = obj1;
46240 {
46241 PyThreadState* __tstate = wxPyBeginAllowThreads();
46242 wxSizer__setOORInfo(arg1,arg2);
46243 wxPyEndAllowThreads(__tstate);
46244 if (PyErr_Occurred()) SWIG_fail;
46245 }
46246 resultobj = SWIG_Py_Void();
46247 return resultobj;
46248 fail:
46249 return NULL;
46250 }
46251
46252
46253 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46254 PyObject *resultobj = 0;
46255 wxSizer *arg1 = (wxSizer *) 0 ;
46256 PyObject *arg2 = (PyObject *) 0 ;
46257 int arg3 = (int) 0 ;
46258 int arg4 = (int) 0 ;
46259 int arg5 = (int) 0 ;
46260 PyObject *arg6 = (PyObject *) NULL ;
46261 wxSizerItem *result = 0 ;
46262 void *argp1 = 0 ;
46263 int res1 = 0 ;
46264 int val3 ;
46265 int ecode3 = 0 ;
46266 int val4 ;
46267 int ecode4 = 0 ;
46268 int val5 ;
46269 int ecode5 = 0 ;
46270 PyObject * obj0 = 0 ;
46271 PyObject * obj1 = 0 ;
46272 PyObject * obj2 = 0 ;
46273 PyObject * obj3 = 0 ;
46274 PyObject * obj4 = 0 ;
46275 PyObject * obj5 = 0 ;
46276 char * kwnames[] = {
46277 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46278 };
46279
46280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46282 if (!SWIG_IsOK(res1)) {
46283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46284 }
46285 arg1 = reinterpret_cast< wxSizer * >(argp1);
46286 arg2 = obj1;
46287 if (obj2) {
46288 ecode3 = SWIG_AsVal_int(obj2, &val3);
46289 if (!SWIG_IsOK(ecode3)) {
46290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46291 }
46292 arg3 = static_cast< int >(val3);
46293 }
46294 if (obj3) {
46295 ecode4 = SWIG_AsVal_int(obj3, &val4);
46296 if (!SWIG_IsOK(ecode4)) {
46297 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46298 }
46299 arg4 = static_cast< int >(val4);
46300 }
46301 if (obj4) {
46302 ecode5 = SWIG_AsVal_int(obj4, &val5);
46303 if (!SWIG_IsOK(ecode5)) {
46304 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46305 }
46306 arg5 = static_cast< int >(val5);
46307 }
46308 if (obj5) {
46309 arg6 = obj5;
46310 }
46311 {
46312 PyThreadState* __tstate = wxPyBeginAllowThreads();
46313 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46314 wxPyEndAllowThreads(__tstate);
46315 if (PyErr_Occurred()) SWIG_fail;
46316 }
46317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46318 return resultobj;
46319 fail:
46320 return NULL;
46321 }
46322
46323
46324 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46325 PyObject *resultobj = 0;
46326 wxSizer *arg1 = (wxSizer *) 0 ;
46327 int arg2 ;
46328 PyObject *arg3 = (PyObject *) 0 ;
46329 int arg4 = (int) 0 ;
46330 int arg5 = (int) 0 ;
46331 int arg6 = (int) 0 ;
46332 PyObject *arg7 = (PyObject *) NULL ;
46333 wxSizerItem *result = 0 ;
46334 void *argp1 = 0 ;
46335 int res1 = 0 ;
46336 int val2 ;
46337 int ecode2 = 0 ;
46338 int val4 ;
46339 int ecode4 = 0 ;
46340 int val5 ;
46341 int ecode5 = 0 ;
46342 int val6 ;
46343 int ecode6 = 0 ;
46344 PyObject * obj0 = 0 ;
46345 PyObject * obj1 = 0 ;
46346 PyObject * obj2 = 0 ;
46347 PyObject * obj3 = 0 ;
46348 PyObject * obj4 = 0 ;
46349 PyObject * obj5 = 0 ;
46350 PyObject * obj6 = 0 ;
46351 char * kwnames[] = {
46352 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46353 };
46354
46355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46357 if (!SWIG_IsOK(res1)) {
46358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46359 }
46360 arg1 = reinterpret_cast< wxSizer * >(argp1);
46361 ecode2 = SWIG_AsVal_int(obj1, &val2);
46362 if (!SWIG_IsOK(ecode2)) {
46363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46364 }
46365 arg2 = static_cast< int >(val2);
46366 arg3 = obj2;
46367 if (obj3) {
46368 ecode4 = SWIG_AsVal_int(obj3, &val4);
46369 if (!SWIG_IsOK(ecode4)) {
46370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46371 }
46372 arg4 = static_cast< int >(val4);
46373 }
46374 if (obj4) {
46375 ecode5 = SWIG_AsVal_int(obj4, &val5);
46376 if (!SWIG_IsOK(ecode5)) {
46377 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46378 }
46379 arg5 = static_cast< int >(val5);
46380 }
46381 if (obj5) {
46382 ecode6 = SWIG_AsVal_int(obj5, &val6);
46383 if (!SWIG_IsOK(ecode6)) {
46384 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46385 }
46386 arg6 = static_cast< int >(val6);
46387 }
46388 if (obj6) {
46389 arg7 = obj6;
46390 }
46391 {
46392 PyThreadState* __tstate = wxPyBeginAllowThreads();
46393 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46394 wxPyEndAllowThreads(__tstate);
46395 if (PyErr_Occurred()) SWIG_fail;
46396 }
46397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46398 return resultobj;
46399 fail:
46400 return NULL;
46401 }
46402
46403
46404 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46405 PyObject *resultobj = 0;
46406 wxSizer *arg1 = (wxSizer *) 0 ;
46407 PyObject *arg2 = (PyObject *) 0 ;
46408 int arg3 = (int) 0 ;
46409 int arg4 = (int) 0 ;
46410 int arg5 = (int) 0 ;
46411 PyObject *arg6 = (PyObject *) NULL ;
46412 wxSizerItem *result = 0 ;
46413 void *argp1 = 0 ;
46414 int res1 = 0 ;
46415 int val3 ;
46416 int ecode3 = 0 ;
46417 int val4 ;
46418 int ecode4 = 0 ;
46419 int val5 ;
46420 int ecode5 = 0 ;
46421 PyObject * obj0 = 0 ;
46422 PyObject * obj1 = 0 ;
46423 PyObject * obj2 = 0 ;
46424 PyObject * obj3 = 0 ;
46425 PyObject * obj4 = 0 ;
46426 PyObject * obj5 = 0 ;
46427 char * kwnames[] = {
46428 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46429 };
46430
46431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46433 if (!SWIG_IsOK(res1)) {
46434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46435 }
46436 arg1 = reinterpret_cast< wxSizer * >(argp1);
46437 arg2 = obj1;
46438 if (obj2) {
46439 ecode3 = SWIG_AsVal_int(obj2, &val3);
46440 if (!SWIG_IsOK(ecode3)) {
46441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46442 }
46443 arg3 = static_cast< int >(val3);
46444 }
46445 if (obj3) {
46446 ecode4 = SWIG_AsVal_int(obj3, &val4);
46447 if (!SWIG_IsOK(ecode4)) {
46448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46449 }
46450 arg4 = static_cast< int >(val4);
46451 }
46452 if (obj4) {
46453 ecode5 = SWIG_AsVal_int(obj4, &val5);
46454 if (!SWIG_IsOK(ecode5)) {
46455 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46456 }
46457 arg5 = static_cast< int >(val5);
46458 }
46459 if (obj5) {
46460 arg6 = obj5;
46461 }
46462 {
46463 PyThreadState* __tstate = wxPyBeginAllowThreads();
46464 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46465 wxPyEndAllowThreads(__tstate);
46466 if (PyErr_Occurred()) SWIG_fail;
46467 }
46468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46469 return resultobj;
46470 fail:
46471 return NULL;
46472 }
46473
46474
46475 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46476 PyObject *resultobj = 0;
46477 wxSizer *arg1 = (wxSizer *) 0 ;
46478 PyObject *arg2 = (PyObject *) 0 ;
46479 bool result;
46480 void *argp1 = 0 ;
46481 int res1 = 0 ;
46482 PyObject * obj0 = 0 ;
46483 PyObject * obj1 = 0 ;
46484 char * kwnames[] = {
46485 (char *) "self",(char *) "item", NULL
46486 };
46487
46488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46490 if (!SWIG_IsOK(res1)) {
46491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46492 }
46493 arg1 = reinterpret_cast< wxSizer * >(argp1);
46494 arg2 = obj1;
46495 {
46496 PyThreadState* __tstate = wxPyBeginAllowThreads();
46497 result = (bool)wxSizer_Remove(arg1,arg2);
46498 wxPyEndAllowThreads(__tstate);
46499 if (PyErr_Occurred()) SWIG_fail;
46500 }
46501 {
46502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46503 }
46504 return resultobj;
46505 fail:
46506 return NULL;
46507 }
46508
46509
46510 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46511 PyObject *resultobj = 0;
46512 wxSizer *arg1 = (wxSizer *) 0 ;
46513 PyObject *arg2 = (PyObject *) 0 ;
46514 bool result;
46515 void *argp1 = 0 ;
46516 int res1 = 0 ;
46517 PyObject * obj0 = 0 ;
46518 PyObject * obj1 = 0 ;
46519 char * kwnames[] = {
46520 (char *) "self",(char *) "item", NULL
46521 };
46522
46523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46525 if (!SWIG_IsOK(res1)) {
46526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46527 }
46528 arg1 = reinterpret_cast< wxSizer * >(argp1);
46529 arg2 = obj1;
46530 {
46531 PyThreadState* __tstate = wxPyBeginAllowThreads();
46532 result = (bool)wxSizer_Detach(arg1,arg2);
46533 wxPyEndAllowThreads(__tstate);
46534 if (PyErr_Occurred()) SWIG_fail;
46535 }
46536 {
46537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46538 }
46539 return resultobj;
46540 fail:
46541 return NULL;
46542 }
46543
46544
46545 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46546 PyObject *resultobj = 0;
46547 wxSizer *arg1 = (wxSizer *) 0 ;
46548 PyObject *arg2 = (PyObject *) 0 ;
46549 wxSizerItem *result = 0 ;
46550 void *argp1 = 0 ;
46551 int res1 = 0 ;
46552 PyObject * obj0 = 0 ;
46553 PyObject * obj1 = 0 ;
46554 char * kwnames[] = {
46555 (char *) "self",(char *) "item", NULL
46556 };
46557
46558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46560 if (!SWIG_IsOK(res1)) {
46561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46562 }
46563 arg1 = reinterpret_cast< wxSizer * >(argp1);
46564 arg2 = obj1;
46565 {
46566 PyThreadState* __tstate = wxPyBeginAllowThreads();
46567 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46568 wxPyEndAllowThreads(__tstate);
46569 if (PyErr_Occurred()) SWIG_fail;
46570 }
46571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46572 return resultobj;
46573 fail:
46574 return NULL;
46575 }
46576
46577
46578 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46579 PyObject *resultobj = 0;
46580 wxSizer *arg1 = (wxSizer *) 0 ;
46581 PyObject *arg2 = (PyObject *) 0 ;
46582 wxSize *arg3 = 0 ;
46583 void *argp1 = 0 ;
46584 int res1 = 0 ;
46585 wxSize temp3 ;
46586 PyObject * obj0 = 0 ;
46587 PyObject * obj1 = 0 ;
46588 PyObject * obj2 = 0 ;
46589 char * kwnames[] = {
46590 (char *) "self",(char *) "item",(char *) "size", NULL
46591 };
46592
46593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46595 if (!SWIG_IsOK(res1)) {
46596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46597 }
46598 arg1 = reinterpret_cast< wxSizer * >(argp1);
46599 arg2 = obj1;
46600 {
46601 arg3 = &temp3;
46602 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46603 }
46604 {
46605 PyThreadState* __tstate = wxPyBeginAllowThreads();
46606 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46607 wxPyEndAllowThreads(__tstate);
46608 if (PyErr_Occurred()) SWIG_fail;
46609 }
46610 resultobj = SWIG_Py_Void();
46611 return resultobj;
46612 fail:
46613 return NULL;
46614 }
46615
46616
46617 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46618 PyObject *resultobj = 0;
46619 wxSizer *arg1 = (wxSizer *) 0 ;
46620 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46621 wxSizerItem *result = 0 ;
46622 void *argp1 = 0 ;
46623 int res1 = 0 ;
46624 int res2 = 0 ;
46625 PyObject * obj0 = 0 ;
46626 PyObject * obj1 = 0 ;
46627 char * kwnames[] = {
46628 (char *) "self",(char *) "item", NULL
46629 };
46630
46631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46633 if (!SWIG_IsOK(res1)) {
46634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46635 }
46636 arg1 = reinterpret_cast< wxSizer * >(argp1);
46637 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46638 if (!SWIG_IsOK(res2)) {
46639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46640 }
46641 {
46642 PyThreadState* __tstate = wxPyBeginAllowThreads();
46643 result = (wxSizerItem *)(arg1)->Add(arg2);
46644 wxPyEndAllowThreads(__tstate);
46645 if (PyErr_Occurred()) SWIG_fail;
46646 }
46647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46648 return resultobj;
46649 fail:
46650 return NULL;
46651 }
46652
46653
46654 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46655 PyObject *resultobj = 0;
46656 wxSizer *arg1 = (wxSizer *) 0 ;
46657 size_t arg2 ;
46658 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46659 wxSizerItem *result = 0 ;
46660 void *argp1 = 0 ;
46661 int res1 = 0 ;
46662 size_t val2 ;
46663 int ecode2 = 0 ;
46664 int res3 = 0 ;
46665 PyObject * obj0 = 0 ;
46666 PyObject * obj1 = 0 ;
46667 PyObject * obj2 = 0 ;
46668 char * kwnames[] = {
46669 (char *) "self",(char *) "index",(char *) "item", NULL
46670 };
46671
46672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46674 if (!SWIG_IsOK(res1)) {
46675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46676 }
46677 arg1 = reinterpret_cast< wxSizer * >(argp1);
46678 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46679 if (!SWIG_IsOK(ecode2)) {
46680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46681 }
46682 arg2 = static_cast< size_t >(val2);
46683 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46684 if (!SWIG_IsOK(res3)) {
46685 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46686 }
46687 {
46688 PyThreadState* __tstate = wxPyBeginAllowThreads();
46689 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46690 wxPyEndAllowThreads(__tstate);
46691 if (PyErr_Occurred()) SWIG_fail;
46692 }
46693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46694 return resultobj;
46695 fail:
46696 return NULL;
46697 }
46698
46699
46700 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46701 PyObject *resultobj = 0;
46702 wxSizer *arg1 = (wxSizer *) 0 ;
46703 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46704 wxSizerItem *result = 0 ;
46705 void *argp1 = 0 ;
46706 int res1 = 0 ;
46707 int res2 = 0 ;
46708 PyObject * obj0 = 0 ;
46709 PyObject * obj1 = 0 ;
46710 char * kwnames[] = {
46711 (char *) "self",(char *) "item", NULL
46712 };
46713
46714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46716 if (!SWIG_IsOK(res1)) {
46717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46718 }
46719 arg1 = reinterpret_cast< wxSizer * >(argp1);
46720 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46721 if (!SWIG_IsOK(res2)) {
46722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46723 }
46724 {
46725 PyThreadState* __tstate = wxPyBeginAllowThreads();
46726 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46727 wxPyEndAllowThreads(__tstate);
46728 if (PyErr_Occurred()) SWIG_fail;
46729 }
46730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46731 return resultobj;
46732 fail:
46733 return NULL;
46734 }
46735
46736
46737 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46738 PyObject *resultobj = 0;
46739 wxSizer *arg1 = (wxSizer *) 0 ;
46740 int arg2 ;
46741 int arg3 ;
46742 int arg4 ;
46743 int arg5 ;
46744 void *argp1 = 0 ;
46745 int res1 = 0 ;
46746 int val2 ;
46747 int ecode2 = 0 ;
46748 int val3 ;
46749 int ecode3 = 0 ;
46750 int val4 ;
46751 int ecode4 = 0 ;
46752 int val5 ;
46753 int ecode5 = 0 ;
46754 PyObject * obj0 = 0 ;
46755 PyObject * obj1 = 0 ;
46756 PyObject * obj2 = 0 ;
46757 PyObject * obj3 = 0 ;
46758 PyObject * obj4 = 0 ;
46759 char * kwnames[] = {
46760 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46761 };
46762
46763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46765 if (!SWIG_IsOK(res1)) {
46766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46767 }
46768 arg1 = reinterpret_cast< wxSizer * >(argp1);
46769 ecode2 = SWIG_AsVal_int(obj1, &val2);
46770 if (!SWIG_IsOK(ecode2)) {
46771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46772 }
46773 arg2 = static_cast< int >(val2);
46774 ecode3 = SWIG_AsVal_int(obj2, &val3);
46775 if (!SWIG_IsOK(ecode3)) {
46776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46777 }
46778 arg3 = static_cast< int >(val3);
46779 ecode4 = SWIG_AsVal_int(obj3, &val4);
46780 if (!SWIG_IsOK(ecode4)) {
46781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46782 }
46783 arg4 = static_cast< int >(val4);
46784 ecode5 = SWIG_AsVal_int(obj4, &val5);
46785 if (!SWIG_IsOK(ecode5)) {
46786 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46787 }
46788 arg5 = static_cast< int >(val5);
46789 {
46790 PyThreadState* __tstate = wxPyBeginAllowThreads();
46791 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46792 wxPyEndAllowThreads(__tstate);
46793 if (PyErr_Occurred()) SWIG_fail;
46794 }
46795 resultobj = SWIG_Py_Void();
46796 return resultobj;
46797 fail:
46798 return NULL;
46799 }
46800
46801
46802 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46803 PyObject *resultobj = 0;
46804 wxSizer *arg1 = (wxSizer *) 0 ;
46805 wxSize *arg2 = 0 ;
46806 void *argp1 = 0 ;
46807 int res1 = 0 ;
46808 wxSize temp2 ;
46809 PyObject * obj0 = 0 ;
46810 PyObject * obj1 = 0 ;
46811 char * kwnames[] = {
46812 (char *) "self",(char *) "size", NULL
46813 };
46814
46815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46817 if (!SWIG_IsOK(res1)) {
46818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46819 }
46820 arg1 = reinterpret_cast< wxSizer * >(argp1);
46821 {
46822 arg2 = &temp2;
46823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46824 }
46825 {
46826 PyThreadState* __tstate = wxPyBeginAllowThreads();
46827 (arg1)->SetMinSize((wxSize const &)*arg2);
46828 wxPyEndAllowThreads(__tstate);
46829 if (PyErr_Occurred()) SWIG_fail;
46830 }
46831 resultobj = SWIG_Py_Void();
46832 return resultobj;
46833 fail:
46834 return NULL;
46835 }
46836
46837
46838 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46839 PyObject *resultobj = 0;
46840 wxSizer *arg1 = (wxSizer *) 0 ;
46841 wxSize result;
46842 void *argp1 = 0 ;
46843 int res1 = 0 ;
46844 PyObject *swig_obj[1] ;
46845
46846 if (!args) SWIG_fail;
46847 swig_obj[0] = args;
46848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46849 if (!SWIG_IsOK(res1)) {
46850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46851 }
46852 arg1 = reinterpret_cast< wxSizer * >(argp1);
46853 {
46854 PyThreadState* __tstate = wxPyBeginAllowThreads();
46855 result = (arg1)->GetSize();
46856 wxPyEndAllowThreads(__tstate);
46857 if (PyErr_Occurred()) SWIG_fail;
46858 }
46859 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46860 return resultobj;
46861 fail:
46862 return NULL;
46863 }
46864
46865
46866 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46867 PyObject *resultobj = 0;
46868 wxSizer *arg1 = (wxSizer *) 0 ;
46869 wxPoint result;
46870 void *argp1 = 0 ;
46871 int res1 = 0 ;
46872 PyObject *swig_obj[1] ;
46873
46874 if (!args) SWIG_fail;
46875 swig_obj[0] = args;
46876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46877 if (!SWIG_IsOK(res1)) {
46878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46879 }
46880 arg1 = reinterpret_cast< wxSizer * >(argp1);
46881 {
46882 PyThreadState* __tstate = wxPyBeginAllowThreads();
46883 result = (arg1)->GetPosition();
46884 wxPyEndAllowThreads(__tstate);
46885 if (PyErr_Occurred()) SWIG_fail;
46886 }
46887 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46888 return resultobj;
46889 fail:
46890 return NULL;
46891 }
46892
46893
46894 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46895 PyObject *resultobj = 0;
46896 wxSizer *arg1 = (wxSizer *) 0 ;
46897 wxSize result;
46898 void *argp1 = 0 ;
46899 int res1 = 0 ;
46900 PyObject *swig_obj[1] ;
46901
46902 if (!args) SWIG_fail;
46903 swig_obj[0] = args;
46904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46905 if (!SWIG_IsOK(res1)) {
46906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46907 }
46908 arg1 = reinterpret_cast< wxSizer * >(argp1);
46909 {
46910 PyThreadState* __tstate = wxPyBeginAllowThreads();
46911 result = (arg1)->GetMinSize();
46912 wxPyEndAllowThreads(__tstate);
46913 if (PyErr_Occurred()) SWIG_fail;
46914 }
46915 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46916 return resultobj;
46917 fail:
46918 return NULL;
46919 }
46920
46921
46922 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46923 PyObject *resultobj = 0;
46924 wxSizer *arg1 = (wxSizer *) 0 ;
46925 void *argp1 = 0 ;
46926 int res1 = 0 ;
46927 PyObject *swig_obj[1] ;
46928
46929 if (!args) SWIG_fail;
46930 swig_obj[0] = args;
46931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46932 if (!SWIG_IsOK(res1)) {
46933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46934 }
46935 arg1 = reinterpret_cast< wxSizer * >(argp1);
46936 {
46937 PyThreadState* __tstate = wxPyBeginAllowThreads();
46938 (arg1)->RecalcSizes();
46939 wxPyEndAllowThreads(__tstate);
46940 if (PyErr_Occurred()) SWIG_fail;
46941 }
46942 resultobj = SWIG_Py_Void();
46943 return resultobj;
46944 fail:
46945 return NULL;
46946 }
46947
46948
46949 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46950 PyObject *resultobj = 0;
46951 wxSizer *arg1 = (wxSizer *) 0 ;
46952 wxSize result;
46953 void *argp1 = 0 ;
46954 int res1 = 0 ;
46955 PyObject *swig_obj[1] ;
46956
46957 if (!args) SWIG_fail;
46958 swig_obj[0] = args;
46959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46960 if (!SWIG_IsOK(res1)) {
46961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46962 }
46963 arg1 = reinterpret_cast< wxSizer * >(argp1);
46964 {
46965 PyThreadState* __tstate = wxPyBeginAllowThreads();
46966 result = (arg1)->CalcMin();
46967 wxPyEndAllowThreads(__tstate);
46968 if (PyErr_Occurred()) SWIG_fail;
46969 }
46970 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46971 return resultobj;
46972 fail:
46973 return NULL;
46974 }
46975
46976
46977 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46978 PyObject *resultobj = 0;
46979 wxSizer *arg1 = (wxSizer *) 0 ;
46980 void *argp1 = 0 ;
46981 int res1 = 0 ;
46982 PyObject *swig_obj[1] ;
46983
46984 if (!args) SWIG_fail;
46985 swig_obj[0] = args;
46986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46987 if (!SWIG_IsOK(res1)) {
46988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46989 }
46990 arg1 = reinterpret_cast< wxSizer * >(argp1);
46991 {
46992 PyThreadState* __tstate = wxPyBeginAllowThreads();
46993 (arg1)->Layout();
46994 wxPyEndAllowThreads(__tstate);
46995 if (PyErr_Occurred()) SWIG_fail;
46996 }
46997 resultobj = SWIG_Py_Void();
46998 return resultobj;
46999 fail:
47000 return NULL;
47001 }
47002
47003
47004 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47005 PyObject *resultobj = 0;
47006 wxSizer *arg1 = (wxSizer *) 0 ;
47007 wxWindow *arg2 = (wxWindow *) 0 ;
47008 wxSize result;
47009 void *argp1 = 0 ;
47010 int res1 = 0 ;
47011 void *argp2 = 0 ;
47012 int res2 = 0 ;
47013 PyObject * obj0 = 0 ;
47014 PyObject * obj1 = 0 ;
47015 char * kwnames[] = {
47016 (char *) "self",(char *) "window", NULL
47017 };
47018
47019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47021 if (!SWIG_IsOK(res1)) {
47022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47023 }
47024 arg1 = reinterpret_cast< wxSizer * >(argp1);
47025 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47026 if (!SWIG_IsOK(res2)) {
47027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47028 }
47029 arg2 = reinterpret_cast< wxWindow * >(argp2);
47030 {
47031 PyThreadState* __tstate = wxPyBeginAllowThreads();
47032 result = (arg1)->Fit(arg2);
47033 wxPyEndAllowThreads(__tstate);
47034 if (PyErr_Occurred()) SWIG_fail;
47035 }
47036 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47037 return resultobj;
47038 fail:
47039 return NULL;
47040 }
47041
47042
47043 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47044 PyObject *resultobj = 0;
47045 wxSizer *arg1 = (wxSizer *) 0 ;
47046 wxWindow *arg2 = (wxWindow *) 0 ;
47047 void *argp1 = 0 ;
47048 int res1 = 0 ;
47049 void *argp2 = 0 ;
47050 int res2 = 0 ;
47051 PyObject * obj0 = 0 ;
47052 PyObject * obj1 = 0 ;
47053 char * kwnames[] = {
47054 (char *) "self",(char *) "window", NULL
47055 };
47056
47057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47059 if (!SWIG_IsOK(res1)) {
47060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47061 }
47062 arg1 = reinterpret_cast< wxSizer * >(argp1);
47063 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47064 if (!SWIG_IsOK(res2)) {
47065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47066 }
47067 arg2 = reinterpret_cast< wxWindow * >(argp2);
47068 {
47069 PyThreadState* __tstate = wxPyBeginAllowThreads();
47070 (arg1)->FitInside(arg2);
47071 wxPyEndAllowThreads(__tstate);
47072 if (PyErr_Occurred()) SWIG_fail;
47073 }
47074 resultobj = SWIG_Py_Void();
47075 return resultobj;
47076 fail:
47077 return NULL;
47078 }
47079
47080
47081 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47082 PyObject *resultobj = 0;
47083 wxSizer *arg1 = (wxSizer *) 0 ;
47084 wxWindow *arg2 = (wxWindow *) 0 ;
47085 void *argp1 = 0 ;
47086 int res1 = 0 ;
47087 void *argp2 = 0 ;
47088 int res2 = 0 ;
47089 PyObject * obj0 = 0 ;
47090 PyObject * obj1 = 0 ;
47091 char * kwnames[] = {
47092 (char *) "self",(char *) "window", NULL
47093 };
47094
47095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47097 if (!SWIG_IsOK(res1)) {
47098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47099 }
47100 arg1 = reinterpret_cast< wxSizer * >(argp1);
47101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47102 if (!SWIG_IsOK(res2)) {
47103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47104 }
47105 arg2 = reinterpret_cast< wxWindow * >(argp2);
47106 {
47107 PyThreadState* __tstate = wxPyBeginAllowThreads();
47108 (arg1)->SetSizeHints(arg2);
47109 wxPyEndAllowThreads(__tstate);
47110 if (PyErr_Occurred()) SWIG_fail;
47111 }
47112 resultobj = SWIG_Py_Void();
47113 return resultobj;
47114 fail:
47115 return NULL;
47116 }
47117
47118
47119 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47120 PyObject *resultobj = 0;
47121 wxSizer *arg1 = (wxSizer *) 0 ;
47122 wxWindow *arg2 = (wxWindow *) 0 ;
47123 void *argp1 = 0 ;
47124 int res1 = 0 ;
47125 void *argp2 = 0 ;
47126 int res2 = 0 ;
47127 PyObject * obj0 = 0 ;
47128 PyObject * obj1 = 0 ;
47129 char * kwnames[] = {
47130 (char *) "self",(char *) "window", NULL
47131 };
47132
47133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47135 if (!SWIG_IsOK(res1)) {
47136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47137 }
47138 arg1 = reinterpret_cast< wxSizer * >(argp1);
47139 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47140 if (!SWIG_IsOK(res2)) {
47141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47142 }
47143 arg2 = reinterpret_cast< wxWindow * >(argp2);
47144 {
47145 PyThreadState* __tstate = wxPyBeginAllowThreads();
47146 (arg1)->SetVirtualSizeHints(arg2);
47147 wxPyEndAllowThreads(__tstate);
47148 if (PyErr_Occurred()) SWIG_fail;
47149 }
47150 resultobj = SWIG_Py_Void();
47151 return resultobj;
47152 fail:
47153 return NULL;
47154 }
47155
47156
47157 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47158 PyObject *resultobj = 0;
47159 wxSizer *arg1 = (wxSizer *) 0 ;
47160 bool arg2 = (bool) false ;
47161 void *argp1 = 0 ;
47162 int res1 = 0 ;
47163 bool val2 ;
47164 int ecode2 = 0 ;
47165 PyObject * obj0 = 0 ;
47166 PyObject * obj1 = 0 ;
47167 char * kwnames[] = {
47168 (char *) "self",(char *) "deleteWindows", NULL
47169 };
47170
47171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47173 if (!SWIG_IsOK(res1)) {
47174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47175 }
47176 arg1 = reinterpret_cast< wxSizer * >(argp1);
47177 if (obj1) {
47178 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47179 if (!SWIG_IsOK(ecode2)) {
47180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47181 }
47182 arg2 = static_cast< bool >(val2);
47183 }
47184 {
47185 PyThreadState* __tstate = wxPyBeginAllowThreads();
47186 (arg1)->Clear(arg2);
47187 wxPyEndAllowThreads(__tstate);
47188 if (PyErr_Occurred()) SWIG_fail;
47189 }
47190 resultobj = SWIG_Py_Void();
47191 return resultobj;
47192 fail:
47193 return NULL;
47194 }
47195
47196
47197 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47198 PyObject *resultobj = 0;
47199 wxSizer *arg1 = (wxSizer *) 0 ;
47200 void *argp1 = 0 ;
47201 int res1 = 0 ;
47202 PyObject *swig_obj[1] ;
47203
47204 if (!args) SWIG_fail;
47205 swig_obj[0] = args;
47206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47207 if (!SWIG_IsOK(res1)) {
47208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47209 }
47210 arg1 = reinterpret_cast< wxSizer * >(argp1);
47211 {
47212 PyThreadState* __tstate = wxPyBeginAllowThreads();
47213 (arg1)->DeleteWindows();
47214 wxPyEndAllowThreads(__tstate);
47215 if (PyErr_Occurred()) SWIG_fail;
47216 }
47217 resultobj = SWIG_Py_Void();
47218 return resultobj;
47219 fail:
47220 return NULL;
47221 }
47222
47223
47224 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47225 PyObject *resultobj = 0;
47226 wxSizer *arg1 = (wxSizer *) 0 ;
47227 PyObject *result = 0 ;
47228 void *argp1 = 0 ;
47229 int res1 = 0 ;
47230 PyObject *swig_obj[1] ;
47231
47232 if (!args) SWIG_fail;
47233 swig_obj[0] = args;
47234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47235 if (!SWIG_IsOK(res1)) {
47236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47237 }
47238 arg1 = reinterpret_cast< wxSizer * >(argp1);
47239 {
47240 PyThreadState* __tstate = wxPyBeginAllowThreads();
47241 result = (PyObject *)wxSizer_GetChildren(arg1);
47242 wxPyEndAllowThreads(__tstate);
47243 if (PyErr_Occurred()) SWIG_fail;
47244 }
47245 resultobj = result;
47246 return resultobj;
47247 fail:
47248 return NULL;
47249 }
47250
47251
47252 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47253 PyObject *resultobj = 0;
47254 wxSizer *arg1 = (wxSizer *) 0 ;
47255 PyObject *arg2 = (PyObject *) 0 ;
47256 bool arg3 = (bool) true ;
47257 bool arg4 = (bool) false ;
47258 bool result;
47259 void *argp1 = 0 ;
47260 int res1 = 0 ;
47261 bool val3 ;
47262 int ecode3 = 0 ;
47263 bool val4 ;
47264 int ecode4 = 0 ;
47265 PyObject * obj0 = 0 ;
47266 PyObject * obj1 = 0 ;
47267 PyObject * obj2 = 0 ;
47268 PyObject * obj3 = 0 ;
47269 char * kwnames[] = {
47270 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47271 };
47272
47273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47275 if (!SWIG_IsOK(res1)) {
47276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47277 }
47278 arg1 = reinterpret_cast< wxSizer * >(argp1);
47279 arg2 = obj1;
47280 if (obj2) {
47281 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47282 if (!SWIG_IsOK(ecode3)) {
47283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47284 }
47285 arg3 = static_cast< bool >(val3);
47286 }
47287 if (obj3) {
47288 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47289 if (!SWIG_IsOK(ecode4)) {
47290 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47291 }
47292 arg4 = static_cast< bool >(val4);
47293 }
47294 {
47295 PyThreadState* __tstate = wxPyBeginAllowThreads();
47296 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47297 wxPyEndAllowThreads(__tstate);
47298 if (PyErr_Occurred()) SWIG_fail;
47299 }
47300 {
47301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47302 }
47303 return resultobj;
47304 fail:
47305 return NULL;
47306 }
47307
47308
47309 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47310 PyObject *resultobj = 0;
47311 wxSizer *arg1 = (wxSizer *) 0 ;
47312 PyObject *arg2 = (PyObject *) 0 ;
47313 bool result;
47314 void *argp1 = 0 ;
47315 int res1 = 0 ;
47316 PyObject * obj0 = 0 ;
47317 PyObject * obj1 = 0 ;
47318 char * kwnames[] = {
47319 (char *) "self",(char *) "item", NULL
47320 };
47321
47322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47324 if (!SWIG_IsOK(res1)) {
47325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47326 }
47327 arg1 = reinterpret_cast< wxSizer * >(argp1);
47328 arg2 = obj1;
47329 {
47330 PyThreadState* __tstate = wxPyBeginAllowThreads();
47331 result = (bool)wxSizer_IsShown(arg1,arg2);
47332 wxPyEndAllowThreads(__tstate);
47333 if (PyErr_Occurred()) SWIG_fail;
47334 }
47335 {
47336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47337 }
47338 return resultobj;
47339 fail:
47340 return NULL;
47341 }
47342
47343
47344 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47345 PyObject *resultobj = 0;
47346 wxSizer *arg1 = (wxSizer *) 0 ;
47347 bool arg2 ;
47348 void *argp1 = 0 ;
47349 int res1 = 0 ;
47350 bool val2 ;
47351 int ecode2 = 0 ;
47352 PyObject * obj0 = 0 ;
47353 PyObject * obj1 = 0 ;
47354 char * kwnames[] = {
47355 (char *) "self",(char *) "show", NULL
47356 };
47357
47358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47360 if (!SWIG_IsOK(res1)) {
47361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47362 }
47363 arg1 = reinterpret_cast< wxSizer * >(argp1);
47364 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47365 if (!SWIG_IsOK(ecode2)) {
47366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47367 }
47368 arg2 = static_cast< bool >(val2);
47369 {
47370 PyThreadState* __tstate = wxPyBeginAllowThreads();
47371 (arg1)->ShowItems(arg2);
47372 wxPyEndAllowThreads(__tstate);
47373 if (PyErr_Occurred()) SWIG_fail;
47374 }
47375 resultobj = SWIG_Py_Void();
47376 return resultobj;
47377 fail:
47378 return NULL;
47379 }
47380
47381
47382 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47383 PyObject *obj;
47384 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47385 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47386 return SWIG_Py_Void();
47387 }
47388
47389 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47390 PyObject *resultobj = 0;
47391 wxPySizer *result = 0 ;
47392
47393 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47394 {
47395 PyThreadState* __tstate = wxPyBeginAllowThreads();
47396 result = (wxPySizer *)new wxPySizer();
47397 wxPyEndAllowThreads(__tstate);
47398 if (PyErr_Occurred()) SWIG_fail;
47399 }
47400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47401 return resultobj;
47402 fail:
47403 return NULL;
47404 }
47405
47406
47407 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47408 PyObject *resultobj = 0;
47409 wxPySizer *arg1 = (wxPySizer *) 0 ;
47410 PyObject *arg2 = (PyObject *) 0 ;
47411 PyObject *arg3 = (PyObject *) 0 ;
47412 void *argp1 = 0 ;
47413 int res1 = 0 ;
47414 PyObject * obj0 = 0 ;
47415 PyObject * obj1 = 0 ;
47416 PyObject * obj2 = 0 ;
47417 char * kwnames[] = {
47418 (char *) "self",(char *) "self",(char *) "_class", NULL
47419 };
47420
47421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47423 if (!SWIG_IsOK(res1)) {
47424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47425 }
47426 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47427 arg2 = obj1;
47428 arg3 = obj2;
47429 {
47430 PyThreadState* __tstate = wxPyBeginAllowThreads();
47431 (arg1)->_setCallbackInfo(arg2,arg3);
47432 wxPyEndAllowThreads(__tstate);
47433 if (PyErr_Occurred()) SWIG_fail;
47434 }
47435 resultobj = SWIG_Py_Void();
47436 return resultobj;
47437 fail:
47438 return NULL;
47439 }
47440
47441
47442 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47443 PyObject *obj;
47444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47445 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47446 return SWIG_Py_Void();
47447 }
47448
47449 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47450 return SWIG_Python_InitShadowInstance(args);
47451 }
47452
47453 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47454 PyObject *resultobj = 0;
47455 int arg1 = (int) wxHORIZONTAL ;
47456 wxBoxSizer *result = 0 ;
47457 int val1 ;
47458 int ecode1 = 0 ;
47459 PyObject * obj0 = 0 ;
47460 char * kwnames[] = {
47461 (char *) "orient", NULL
47462 };
47463
47464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47465 if (obj0) {
47466 ecode1 = SWIG_AsVal_int(obj0, &val1);
47467 if (!SWIG_IsOK(ecode1)) {
47468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47469 }
47470 arg1 = static_cast< int >(val1);
47471 }
47472 {
47473 PyThreadState* __tstate = wxPyBeginAllowThreads();
47474 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47475 wxPyEndAllowThreads(__tstate);
47476 if (PyErr_Occurred()) SWIG_fail;
47477 }
47478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47479 return resultobj;
47480 fail:
47481 return NULL;
47482 }
47483
47484
47485 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47486 PyObject *resultobj = 0;
47487 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47488 int result;
47489 void *argp1 = 0 ;
47490 int res1 = 0 ;
47491 PyObject *swig_obj[1] ;
47492
47493 if (!args) SWIG_fail;
47494 swig_obj[0] = args;
47495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47496 if (!SWIG_IsOK(res1)) {
47497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47498 }
47499 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47500 {
47501 PyThreadState* __tstate = wxPyBeginAllowThreads();
47502 result = (int)(arg1)->GetOrientation();
47503 wxPyEndAllowThreads(__tstate);
47504 if (PyErr_Occurred()) SWIG_fail;
47505 }
47506 resultobj = SWIG_From_int(static_cast< int >(result));
47507 return resultobj;
47508 fail:
47509 return NULL;
47510 }
47511
47512
47513 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47514 PyObject *resultobj = 0;
47515 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47516 int arg2 ;
47517 void *argp1 = 0 ;
47518 int res1 = 0 ;
47519 int val2 ;
47520 int ecode2 = 0 ;
47521 PyObject * obj0 = 0 ;
47522 PyObject * obj1 = 0 ;
47523 char * kwnames[] = {
47524 (char *) "self",(char *) "orient", NULL
47525 };
47526
47527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47529 if (!SWIG_IsOK(res1)) {
47530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47531 }
47532 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47533 ecode2 = SWIG_AsVal_int(obj1, &val2);
47534 if (!SWIG_IsOK(ecode2)) {
47535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47536 }
47537 arg2 = static_cast< int >(val2);
47538 {
47539 PyThreadState* __tstate = wxPyBeginAllowThreads();
47540 (arg1)->SetOrientation(arg2);
47541 wxPyEndAllowThreads(__tstate);
47542 if (PyErr_Occurred()) SWIG_fail;
47543 }
47544 resultobj = SWIG_Py_Void();
47545 return resultobj;
47546 fail:
47547 return NULL;
47548 }
47549
47550
47551 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47552 PyObject *obj;
47553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47554 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47555 return SWIG_Py_Void();
47556 }
47557
47558 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47559 return SWIG_Python_InitShadowInstance(args);
47560 }
47561
47562 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47563 PyObject *resultobj = 0;
47564 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47565 int arg2 = (int) wxHORIZONTAL ;
47566 wxStaticBoxSizer *result = 0 ;
47567 void *argp1 = 0 ;
47568 int res1 = 0 ;
47569 int val2 ;
47570 int ecode2 = 0 ;
47571 PyObject * obj0 = 0 ;
47572 PyObject * obj1 = 0 ;
47573 char * kwnames[] = {
47574 (char *) "box",(char *) "orient", NULL
47575 };
47576
47577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47579 if (!SWIG_IsOK(res1)) {
47580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47581 }
47582 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47583 if (obj1) {
47584 ecode2 = SWIG_AsVal_int(obj1, &val2);
47585 if (!SWIG_IsOK(ecode2)) {
47586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47587 }
47588 arg2 = static_cast< int >(val2);
47589 }
47590 {
47591 PyThreadState* __tstate = wxPyBeginAllowThreads();
47592 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47593 wxPyEndAllowThreads(__tstate);
47594 if (PyErr_Occurred()) SWIG_fail;
47595 }
47596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47597 return resultobj;
47598 fail:
47599 return NULL;
47600 }
47601
47602
47603 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47604 PyObject *resultobj = 0;
47605 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47606 wxStaticBox *result = 0 ;
47607 void *argp1 = 0 ;
47608 int res1 = 0 ;
47609 PyObject *swig_obj[1] ;
47610
47611 if (!args) SWIG_fail;
47612 swig_obj[0] = args;
47613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47614 if (!SWIG_IsOK(res1)) {
47615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47616 }
47617 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47618 {
47619 PyThreadState* __tstate = wxPyBeginAllowThreads();
47620 result = (wxStaticBox *)(arg1)->GetStaticBox();
47621 wxPyEndAllowThreads(__tstate);
47622 if (PyErr_Occurred()) SWIG_fail;
47623 }
47624 {
47625 resultobj = wxPyMake_wxObject(result, (bool)0);
47626 }
47627 return resultobj;
47628 fail:
47629 return NULL;
47630 }
47631
47632
47633 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47634 PyObject *obj;
47635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47636 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47637 return SWIG_Py_Void();
47638 }
47639
47640 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47641 return SWIG_Python_InitShadowInstance(args);
47642 }
47643
47644 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47645 PyObject *resultobj = 0;
47646 int arg1 = (int) 1 ;
47647 int arg2 = (int) 0 ;
47648 int arg3 = (int) 0 ;
47649 int arg4 = (int) 0 ;
47650 wxGridSizer *result = 0 ;
47651 int val1 ;
47652 int ecode1 = 0 ;
47653 int val2 ;
47654 int ecode2 = 0 ;
47655 int val3 ;
47656 int ecode3 = 0 ;
47657 int val4 ;
47658 int ecode4 = 0 ;
47659 PyObject * obj0 = 0 ;
47660 PyObject * obj1 = 0 ;
47661 PyObject * obj2 = 0 ;
47662 PyObject * obj3 = 0 ;
47663 char * kwnames[] = {
47664 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47665 };
47666
47667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47668 if (obj0) {
47669 ecode1 = SWIG_AsVal_int(obj0, &val1);
47670 if (!SWIG_IsOK(ecode1)) {
47671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47672 }
47673 arg1 = static_cast< int >(val1);
47674 }
47675 if (obj1) {
47676 ecode2 = SWIG_AsVal_int(obj1, &val2);
47677 if (!SWIG_IsOK(ecode2)) {
47678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47679 }
47680 arg2 = static_cast< int >(val2);
47681 }
47682 if (obj2) {
47683 ecode3 = SWIG_AsVal_int(obj2, &val3);
47684 if (!SWIG_IsOK(ecode3)) {
47685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47686 }
47687 arg3 = static_cast< int >(val3);
47688 }
47689 if (obj3) {
47690 ecode4 = SWIG_AsVal_int(obj3, &val4);
47691 if (!SWIG_IsOK(ecode4)) {
47692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47693 }
47694 arg4 = static_cast< int >(val4);
47695 }
47696 {
47697 PyThreadState* __tstate = wxPyBeginAllowThreads();
47698 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47699 wxPyEndAllowThreads(__tstate);
47700 if (PyErr_Occurred()) SWIG_fail;
47701 }
47702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47703 return resultobj;
47704 fail:
47705 return NULL;
47706 }
47707
47708
47709 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47710 PyObject *resultobj = 0;
47711 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47712 int arg2 ;
47713 void *argp1 = 0 ;
47714 int res1 = 0 ;
47715 int val2 ;
47716 int ecode2 = 0 ;
47717 PyObject * obj0 = 0 ;
47718 PyObject * obj1 = 0 ;
47719 char * kwnames[] = {
47720 (char *) "self",(char *) "cols", NULL
47721 };
47722
47723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47725 if (!SWIG_IsOK(res1)) {
47726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47727 }
47728 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47729 ecode2 = SWIG_AsVal_int(obj1, &val2);
47730 if (!SWIG_IsOK(ecode2)) {
47731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47732 }
47733 arg2 = static_cast< int >(val2);
47734 {
47735 PyThreadState* __tstate = wxPyBeginAllowThreads();
47736 (arg1)->SetCols(arg2);
47737 wxPyEndAllowThreads(__tstate);
47738 if (PyErr_Occurred()) SWIG_fail;
47739 }
47740 resultobj = SWIG_Py_Void();
47741 return resultobj;
47742 fail:
47743 return NULL;
47744 }
47745
47746
47747 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47748 PyObject *resultobj = 0;
47749 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47750 int arg2 ;
47751 void *argp1 = 0 ;
47752 int res1 = 0 ;
47753 int val2 ;
47754 int ecode2 = 0 ;
47755 PyObject * obj0 = 0 ;
47756 PyObject * obj1 = 0 ;
47757 char * kwnames[] = {
47758 (char *) "self",(char *) "rows", NULL
47759 };
47760
47761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47763 if (!SWIG_IsOK(res1)) {
47764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47765 }
47766 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47767 ecode2 = SWIG_AsVal_int(obj1, &val2);
47768 if (!SWIG_IsOK(ecode2)) {
47769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47770 }
47771 arg2 = static_cast< int >(val2);
47772 {
47773 PyThreadState* __tstate = wxPyBeginAllowThreads();
47774 (arg1)->SetRows(arg2);
47775 wxPyEndAllowThreads(__tstate);
47776 if (PyErr_Occurred()) SWIG_fail;
47777 }
47778 resultobj = SWIG_Py_Void();
47779 return resultobj;
47780 fail:
47781 return NULL;
47782 }
47783
47784
47785 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47786 PyObject *resultobj = 0;
47787 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47788 int arg2 ;
47789 void *argp1 = 0 ;
47790 int res1 = 0 ;
47791 int val2 ;
47792 int ecode2 = 0 ;
47793 PyObject * obj0 = 0 ;
47794 PyObject * obj1 = 0 ;
47795 char * kwnames[] = {
47796 (char *) "self",(char *) "gap", NULL
47797 };
47798
47799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47801 if (!SWIG_IsOK(res1)) {
47802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47803 }
47804 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47805 ecode2 = SWIG_AsVal_int(obj1, &val2);
47806 if (!SWIG_IsOK(ecode2)) {
47807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47808 }
47809 arg2 = static_cast< int >(val2);
47810 {
47811 PyThreadState* __tstate = wxPyBeginAllowThreads();
47812 (arg1)->SetVGap(arg2);
47813 wxPyEndAllowThreads(__tstate);
47814 if (PyErr_Occurred()) SWIG_fail;
47815 }
47816 resultobj = SWIG_Py_Void();
47817 return resultobj;
47818 fail:
47819 return NULL;
47820 }
47821
47822
47823 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47824 PyObject *resultobj = 0;
47825 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47826 int arg2 ;
47827 void *argp1 = 0 ;
47828 int res1 = 0 ;
47829 int val2 ;
47830 int ecode2 = 0 ;
47831 PyObject * obj0 = 0 ;
47832 PyObject * obj1 = 0 ;
47833 char * kwnames[] = {
47834 (char *) "self",(char *) "gap", NULL
47835 };
47836
47837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47839 if (!SWIG_IsOK(res1)) {
47840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47841 }
47842 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47843 ecode2 = SWIG_AsVal_int(obj1, &val2);
47844 if (!SWIG_IsOK(ecode2)) {
47845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47846 }
47847 arg2 = static_cast< int >(val2);
47848 {
47849 PyThreadState* __tstate = wxPyBeginAllowThreads();
47850 (arg1)->SetHGap(arg2);
47851 wxPyEndAllowThreads(__tstate);
47852 if (PyErr_Occurred()) SWIG_fail;
47853 }
47854 resultobj = SWIG_Py_Void();
47855 return resultobj;
47856 fail:
47857 return NULL;
47858 }
47859
47860
47861 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47862 PyObject *resultobj = 0;
47863 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47864 int result;
47865 void *argp1 = 0 ;
47866 int res1 = 0 ;
47867 PyObject *swig_obj[1] ;
47868
47869 if (!args) SWIG_fail;
47870 swig_obj[0] = args;
47871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47872 if (!SWIG_IsOK(res1)) {
47873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47874 }
47875 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47876 {
47877 PyThreadState* __tstate = wxPyBeginAllowThreads();
47878 result = (int)(arg1)->GetCols();
47879 wxPyEndAllowThreads(__tstate);
47880 if (PyErr_Occurred()) SWIG_fail;
47881 }
47882 resultobj = SWIG_From_int(static_cast< int >(result));
47883 return resultobj;
47884 fail:
47885 return NULL;
47886 }
47887
47888
47889 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47890 PyObject *resultobj = 0;
47891 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47892 int result;
47893 void *argp1 = 0 ;
47894 int res1 = 0 ;
47895 PyObject *swig_obj[1] ;
47896
47897 if (!args) SWIG_fail;
47898 swig_obj[0] = args;
47899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47900 if (!SWIG_IsOK(res1)) {
47901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47902 }
47903 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47904 {
47905 PyThreadState* __tstate = wxPyBeginAllowThreads();
47906 result = (int)(arg1)->GetRows();
47907 wxPyEndAllowThreads(__tstate);
47908 if (PyErr_Occurred()) SWIG_fail;
47909 }
47910 resultobj = SWIG_From_int(static_cast< int >(result));
47911 return resultobj;
47912 fail:
47913 return NULL;
47914 }
47915
47916
47917 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47918 PyObject *resultobj = 0;
47919 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47920 int result;
47921 void *argp1 = 0 ;
47922 int res1 = 0 ;
47923 PyObject *swig_obj[1] ;
47924
47925 if (!args) SWIG_fail;
47926 swig_obj[0] = args;
47927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47928 if (!SWIG_IsOK(res1)) {
47929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47930 }
47931 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47932 {
47933 PyThreadState* __tstate = wxPyBeginAllowThreads();
47934 result = (int)(arg1)->GetVGap();
47935 wxPyEndAllowThreads(__tstate);
47936 if (PyErr_Occurred()) SWIG_fail;
47937 }
47938 resultobj = SWIG_From_int(static_cast< int >(result));
47939 return resultobj;
47940 fail:
47941 return NULL;
47942 }
47943
47944
47945 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47946 PyObject *resultobj = 0;
47947 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47948 int result;
47949 void *argp1 = 0 ;
47950 int res1 = 0 ;
47951 PyObject *swig_obj[1] ;
47952
47953 if (!args) SWIG_fail;
47954 swig_obj[0] = args;
47955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47956 if (!SWIG_IsOK(res1)) {
47957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47958 }
47959 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47960 {
47961 PyThreadState* __tstate = wxPyBeginAllowThreads();
47962 result = (int)(arg1)->GetHGap();
47963 wxPyEndAllowThreads(__tstate);
47964 if (PyErr_Occurred()) SWIG_fail;
47965 }
47966 resultobj = SWIG_From_int(static_cast< int >(result));
47967 return resultobj;
47968 fail:
47969 return NULL;
47970 }
47971
47972
47973 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47974 PyObject *obj;
47975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47976 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47977 return SWIG_Py_Void();
47978 }
47979
47980 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47981 return SWIG_Python_InitShadowInstance(args);
47982 }
47983
47984 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47985 PyObject *resultobj = 0;
47986 int arg1 = (int) 1 ;
47987 int arg2 = (int) 0 ;
47988 int arg3 = (int) 0 ;
47989 int arg4 = (int) 0 ;
47990 wxFlexGridSizer *result = 0 ;
47991 int val1 ;
47992 int ecode1 = 0 ;
47993 int val2 ;
47994 int ecode2 = 0 ;
47995 int val3 ;
47996 int ecode3 = 0 ;
47997 int val4 ;
47998 int ecode4 = 0 ;
47999 PyObject * obj0 = 0 ;
48000 PyObject * obj1 = 0 ;
48001 PyObject * obj2 = 0 ;
48002 PyObject * obj3 = 0 ;
48003 char * kwnames[] = {
48004 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48005 };
48006
48007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48008 if (obj0) {
48009 ecode1 = SWIG_AsVal_int(obj0, &val1);
48010 if (!SWIG_IsOK(ecode1)) {
48011 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48012 }
48013 arg1 = static_cast< int >(val1);
48014 }
48015 if (obj1) {
48016 ecode2 = SWIG_AsVal_int(obj1, &val2);
48017 if (!SWIG_IsOK(ecode2)) {
48018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48019 }
48020 arg2 = static_cast< int >(val2);
48021 }
48022 if (obj2) {
48023 ecode3 = SWIG_AsVal_int(obj2, &val3);
48024 if (!SWIG_IsOK(ecode3)) {
48025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48026 }
48027 arg3 = static_cast< int >(val3);
48028 }
48029 if (obj3) {
48030 ecode4 = SWIG_AsVal_int(obj3, &val4);
48031 if (!SWIG_IsOK(ecode4)) {
48032 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48033 }
48034 arg4 = static_cast< int >(val4);
48035 }
48036 {
48037 PyThreadState* __tstate = wxPyBeginAllowThreads();
48038 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48039 wxPyEndAllowThreads(__tstate);
48040 if (PyErr_Occurred()) SWIG_fail;
48041 }
48042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48043 return resultobj;
48044 fail:
48045 return NULL;
48046 }
48047
48048
48049 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48050 PyObject *resultobj = 0;
48051 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48052 size_t arg2 ;
48053 int arg3 = (int) 0 ;
48054 void *argp1 = 0 ;
48055 int res1 = 0 ;
48056 size_t val2 ;
48057 int ecode2 = 0 ;
48058 int val3 ;
48059 int ecode3 = 0 ;
48060 PyObject * obj0 = 0 ;
48061 PyObject * obj1 = 0 ;
48062 PyObject * obj2 = 0 ;
48063 char * kwnames[] = {
48064 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48065 };
48066
48067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48069 if (!SWIG_IsOK(res1)) {
48070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48071 }
48072 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48073 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48074 if (!SWIG_IsOK(ecode2)) {
48075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48076 }
48077 arg2 = static_cast< size_t >(val2);
48078 if (obj2) {
48079 ecode3 = SWIG_AsVal_int(obj2, &val3);
48080 if (!SWIG_IsOK(ecode3)) {
48081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48082 }
48083 arg3 = static_cast< int >(val3);
48084 }
48085 {
48086 PyThreadState* __tstate = wxPyBeginAllowThreads();
48087 (arg1)->AddGrowableRow(arg2,arg3);
48088 wxPyEndAllowThreads(__tstate);
48089 if (PyErr_Occurred()) SWIG_fail;
48090 }
48091 resultobj = SWIG_Py_Void();
48092 return resultobj;
48093 fail:
48094 return NULL;
48095 }
48096
48097
48098 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48099 PyObject *resultobj = 0;
48100 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48101 size_t arg2 ;
48102 void *argp1 = 0 ;
48103 int res1 = 0 ;
48104 size_t val2 ;
48105 int ecode2 = 0 ;
48106 PyObject * obj0 = 0 ;
48107 PyObject * obj1 = 0 ;
48108 char * kwnames[] = {
48109 (char *) "self",(char *) "idx", NULL
48110 };
48111
48112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48114 if (!SWIG_IsOK(res1)) {
48115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48116 }
48117 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48118 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48119 if (!SWIG_IsOK(ecode2)) {
48120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48121 }
48122 arg2 = static_cast< size_t >(val2);
48123 {
48124 PyThreadState* __tstate = wxPyBeginAllowThreads();
48125 (arg1)->RemoveGrowableRow(arg2);
48126 wxPyEndAllowThreads(__tstate);
48127 if (PyErr_Occurred()) SWIG_fail;
48128 }
48129 resultobj = SWIG_Py_Void();
48130 return resultobj;
48131 fail:
48132 return NULL;
48133 }
48134
48135
48136 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48137 PyObject *resultobj = 0;
48138 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48139 size_t arg2 ;
48140 int arg3 = (int) 0 ;
48141 void *argp1 = 0 ;
48142 int res1 = 0 ;
48143 size_t val2 ;
48144 int ecode2 = 0 ;
48145 int val3 ;
48146 int ecode3 = 0 ;
48147 PyObject * obj0 = 0 ;
48148 PyObject * obj1 = 0 ;
48149 PyObject * obj2 = 0 ;
48150 char * kwnames[] = {
48151 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48152 };
48153
48154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48156 if (!SWIG_IsOK(res1)) {
48157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48158 }
48159 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48160 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48161 if (!SWIG_IsOK(ecode2)) {
48162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48163 }
48164 arg2 = static_cast< size_t >(val2);
48165 if (obj2) {
48166 ecode3 = SWIG_AsVal_int(obj2, &val3);
48167 if (!SWIG_IsOK(ecode3)) {
48168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48169 }
48170 arg3 = static_cast< int >(val3);
48171 }
48172 {
48173 PyThreadState* __tstate = wxPyBeginAllowThreads();
48174 (arg1)->AddGrowableCol(arg2,arg3);
48175 wxPyEndAllowThreads(__tstate);
48176 if (PyErr_Occurred()) SWIG_fail;
48177 }
48178 resultobj = SWIG_Py_Void();
48179 return resultobj;
48180 fail:
48181 return NULL;
48182 }
48183
48184
48185 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48186 PyObject *resultobj = 0;
48187 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48188 size_t arg2 ;
48189 void *argp1 = 0 ;
48190 int res1 = 0 ;
48191 size_t val2 ;
48192 int ecode2 = 0 ;
48193 PyObject * obj0 = 0 ;
48194 PyObject * obj1 = 0 ;
48195 char * kwnames[] = {
48196 (char *) "self",(char *) "idx", NULL
48197 };
48198
48199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48201 if (!SWIG_IsOK(res1)) {
48202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48203 }
48204 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48205 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48206 if (!SWIG_IsOK(ecode2)) {
48207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48208 }
48209 arg2 = static_cast< size_t >(val2);
48210 {
48211 PyThreadState* __tstate = wxPyBeginAllowThreads();
48212 (arg1)->RemoveGrowableCol(arg2);
48213 wxPyEndAllowThreads(__tstate);
48214 if (PyErr_Occurred()) SWIG_fail;
48215 }
48216 resultobj = SWIG_Py_Void();
48217 return resultobj;
48218 fail:
48219 return NULL;
48220 }
48221
48222
48223 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48224 PyObject *resultobj = 0;
48225 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48226 int arg2 ;
48227 void *argp1 = 0 ;
48228 int res1 = 0 ;
48229 int val2 ;
48230 int ecode2 = 0 ;
48231 PyObject * obj0 = 0 ;
48232 PyObject * obj1 = 0 ;
48233 char * kwnames[] = {
48234 (char *) "self",(char *) "direction", NULL
48235 };
48236
48237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48239 if (!SWIG_IsOK(res1)) {
48240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48241 }
48242 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48243 ecode2 = SWIG_AsVal_int(obj1, &val2);
48244 if (!SWIG_IsOK(ecode2)) {
48245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48246 }
48247 arg2 = static_cast< int >(val2);
48248 {
48249 PyThreadState* __tstate = wxPyBeginAllowThreads();
48250 (arg1)->SetFlexibleDirection(arg2);
48251 wxPyEndAllowThreads(__tstate);
48252 if (PyErr_Occurred()) SWIG_fail;
48253 }
48254 resultobj = SWIG_Py_Void();
48255 return resultobj;
48256 fail:
48257 return NULL;
48258 }
48259
48260
48261 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48262 PyObject *resultobj = 0;
48263 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48264 int result;
48265 void *argp1 = 0 ;
48266 int res1 = 0 ;
48267 PyObject *swig_obj[1] ;
48268
48269 if (!args) SWIG_fail;
48270 swig_obj[0] = args;
48271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48272 if (!SWIG_IsOK(res1)) {
48273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48274 }
48275 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48276 {
48277 PyThreadState* __tstate = wxPyBeginAllowThreads();
48278 result = (int)(arg1)->GetFlexibleDirection();
48279 wxPyEndAllowThreads(__tstate);
48280 if (PyErr_Occurred()) SWIG_fail;
48281 }
48282 resultobj = SWIG_From_int(static_cast< int >(result));
48283 return resultobj;
48284 fail:
48285 return NULL;
48286 }
48287
48288
48289 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48290 PyObject *resultobj = 0;
48291 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48292 wxFlexSizerGrowMode arg2 ;
48293 void *argp1 = 0 ;
48294 int res1 = 0 ;
48295 int val2 ;
48296 int ecode2 = 0 ;
48297 PyObject * obj0 = 0 ;
48298 PyObject * obj1 = 0 ;
48299 char * kwnames[] = {
48300 (char *) "self",(char *) "mode", NULL
48301 };
48302
48303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48305 if (!SWIG_IsOK(res1)) {
48306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48307 }
48308 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48309 ecode2 = SWIG_AsVal_int(obj1, &val2);
48310 if (!SWIG_IsOK(ecode2)) {
48311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48312 }
48313 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48314 {
48315 PyThreadState* __tstate = wxPyBeginAllowThreads();
48316 (arg1)->SetNonFlexibleGrowMode(arg2);
48317 wxPyEndAllowThreads(__tstate);
48318 if (PyErr_Occurred()) SWIG_fail;
48319 }
48320 resultobj = SWIG_Py_Void();
48321 return resultobj;
48322 fail:
48323 return NULL;
48324 }
48325
48326
48327 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48328 PyObject *resultobj = 0;
48329 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48330 wxFlexSizerGrowMode result;
48331 void *argp1 = 0 ;
48332 int res1 = 0 ;
48333 PyObject *swig_obj[1] ;
48334
48335 if (!args) SWIG_fail;
48336 swig_obj[0] = args;
48337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48338 if (!SWIG_IsOK(res1)) {
48339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48340 }
48341 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48342 {
48343 PyThreadState* __tstate = wxPyBeginAllowThreads();
48344 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48345 wxPyEndAllowThreads(__tstate);
48346 if (PyErr_Occurred()) SWIG_fail;
48347 }
48348 resultobj = SWIG_From_int(static_cast< int >(result));
48349 return resultobj;
48350 fail:
48351 return NULL;
48352 }
48353
48354
48355 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48356 PyObject *resultobj = 0;
48357 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48358 wxArrayInt *result = 0 ;
48359 void *argp1 = 0 ;
48360 int res1 = 0 ;
48361 PyObject *swig_obj[1] ;
48362
48363 if (!args) SWIG_fail;
48364 swig_obj[0] = args;
48365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48366 if (!SWIG_IsOK(res1)) {
48367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48368 }
48369 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48370 {
48371 PyThreadState* __tstate = wxPyBeginAllowThreads();
48372 {
48373 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48374 result = (wxArrayInt *) &_result_ref;
48375 }
48376 wxPyEndAllowThreads(__tstate);
48377 if (PyErr_Occurred()) SWIG_fail;
48378 }
48379 {
48380 resultobj = PyList_New(0);
48381 size_t idx;
48382 for (idx = 0; idx < result->GetCount(); idx += 1) {
48383 PyObject* val = PyInt_FromLong( result->Item(idx) );
48384 PyList_Append(resultobj, val);
48385 Py_DECREF(val);
48386 }
48387 }
48388 return resultobj;
48389 fail:
48390 return NULL;
48391 }
48392
48393
48394 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48395 PyObject *resultobj = 0;
48396 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48397 wxArrayInt *result = 0 ;
48398 void *argp1 = 0 ;
48399 int res1 = 0 ;
48400 PyObject *swig_obj[1] ;
48401
48402 if (!args) SWIG_fail;
48403 swig_obj[0] = args;
48404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48405 if (!SWIG_IsOK(res1)) {
48406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48407 }
48408 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48409 {
48410 PyThreadState* __tstate = wxPyBeginAllowThreads();
48411 {
48412 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48413 result = (wxArrayInt *) &_result_ref;
48414 }
48415 wxPyEndAllowThreads(__tstate);
48416 if (PyErr_Occurred()) SWIG_fail;
48417 }
48418 {
48419 resultobj = PyList_New(0);
48420 size_t idx;
48421 for (idx = 0; idx < result->GetCount(); idx += 1) {
48422 PyObject* val = PyInt_FromLong( result->Item(idx) );
48423 PyList_Append(resultobj, val);
48424 Py_DECREF(val);
48425 }
48426 }
48427 return resultobj;
48428 fail:
48429 return NULL;
48430 }
48431
48432
48433 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48434 PyObject *obj;
48435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48436 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48437 return SWIG_Py_Void();
48438 }
48439
48440 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48441 return SWIG_Python_InitShadowInstance(args);
48442 }
48443
48444 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48445 PyObject *resultobj = 0;
48446 wxStdDialogButtonSizer *result = 0 ;
48447
48448 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48449 {
48450 PyThreadState* __tstate = wxPyBeginAllowThreads();
48451 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48452 wxPyEndAllowThreads(__tstate);
48453 if (PyErr_Occurred()) SWIG_fail;
48454 }
48455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48456 return resultobj;
48457 fail:
48458 return NULL;
48459 }
48460
48461
48462 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48463 PyObject *resultobj = 0;
48464 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48465 wxButton *arg2 = (wxButton *) 0 ;
48466 void *argp1 = 0 ;
48467 int res1 = 0 ;
48468 void *argp2 = 0 ;
48469 int res2 = 0 ;
48470 PyObject * obj0 = 0 ;
48471 PyObject * obj1 = 0 ;
48472 char * kwnames[] = {
48473 (char *) "self",(char *) "button", NULL
48474 };
48475
48476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48478 if (!SWIG_IsOK(res1)) {
48479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48480 }
48481 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48482 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48483 if (!SWIG_IsOK(res2)) {
48484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48485 }
48486 arg2 = reinterpret_cast< wxButton * >(argp2);
48487 {
48488 PyThreadState* __tstate = wxPyBeginAllowThreads();
48489 (arg1)->AddButton(arg2);
48490 wxPyEndAllowThreads(__tstate);
48491 if (PyErr_Occurred()) SWIG_fail;
48492 }
48493 resultobj = SWIG_Py_Void();
48494 return resultobj;
48495 fail:
48496 return NULL;
48497 }
48498
48499
48500 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48501 PyObject *resultobj = 0;
48502 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48503 void *argp1 = 0 ;
48504 int res1 = 0 ;
48505 PyObject *swig_obj[1] ;
48506
48507 if (!args) SWIG_fail;
48508 swig_obj[0] = args;
48509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48510 if (!SWIG_IsOK(res1)) {
48511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48512 }
48513 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48514 {
48515 PyThreadState* __tstate = wxPyBeginAllowThreads();
48516 (arg1)->Realize();
48517 wxPyEndAllowThreads(__tstate);
48518 if (PyErr_Occurred()) SWIG_fail;
48519 }
48520 resultobj = SWIG_Py_Void();
48521 return resultobj;
48522 fail:
48523 return NULL;
48524 }
48525
48526
48527 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48528 PyObject *resultobj = 0;
48529 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48530 wxButton *arg2 = (wxButton *) 0 ;
48531 void *argp1 = 0 ;
48532 int res1 = 0 ;
48533 void *argp2 = 0 ;
48534 int res2 = 0 ;
48535 PyObject * obj0 = 0 ;
48536 PyObject * obj1 = 0 ;
48537 char * kwnames[] = {
48538 (char *) "self",(char *) "button", NULL
48539 };
48540
48541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48543 if (!SWIG_IsOK(res1)) {
48544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48545 }
48546 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48548 if (!SWIG_IsOK(res2)) {
48549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48550 }
48551 arg2 = reinterpret_cast< wxButton * >(argp2);
48552 {
48553 PyThreadState* __tstate = wxPyBeginAllowThreads();
48554 (arg1)->SetAffirmativeButton(arg2);
48555 wxPyEndAllowThreads(__tstate);
48556 if (PyErr_Occurred()) SWIG_fail;
48557 }
48558 resultobj = SWIG_Py_Void();
48559 return resultobj;
48560 fail:
48561 return NULL;
48562 }
48563
48564
48565 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48566 PyObject *resultobj = 0;
48567 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48568 wxButton *arg2 = (wxButton *) 0 ;
48569 void *argp1 = 0 ;
48570 int res1 = 0 ;
48571 void *argp2 = 0 ;
48572 int res2 = 0 ;
48573 PyObject * obj0 = 0 ;
48574 PyObject * obj1 = 0 ;
48575 char * kwnames[] = {
48576 (char *) "self",(char *) "button", NULL
48577 };
48578
48579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48581 if (!SWIG_IsOK(res1)) {
48582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48583 }
48584 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48586 if (!SWIG_IsOK(res2)) {
48587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48588 }
48589 arg2 = reinterpret_cast< wxButton * >(argp2);
48590 {
48591 PyThreadState* __tstate = wxPyBeginAllowThreads();
48592 (arg1)->SetNegativeButton(arg2);
48593 wxPyEndAllowThreads(__tstate);
48594 if (PyErr_Occurred()) SWIG_fail;
48595 }
48596 resultobj = SWIG_Py_Void();
48597 return resultobj;
48598 fail:
48599 return NULL;
48600 }
48601
48602
48603 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48604 PyObject *resultobj = 0;
48605 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48606 wxButton *arg2 = (wxButton *) 0 ;
48607 void *argp1 = 0 ;
48608 int res1 = 0 ;
48609 void *argp2 = 0 ;
48610 int res2 = 0 ;
48611 PyObject * obj0 = 0 ;
48612 PyObject * obj1 = 0 ;
48613 char * kwnames[] = {
48614 (char *) "self",(char *) "button", NULL
48615 };
48616
48617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48619 if (!SWIG_IsOK(res1)) {
48620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48621 }
48622 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48624 if (!SWIG_IsOK(res2)) {
48625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48626 }
48627 arg2 = reinterpret_cast< wxButton * >(argp2);
48628 {
48629 PyThreadState* __tstate = wxPyBeginAllowThreads();
48630 (arg1)->SetCancelButton(arg2);
48631 wxPyEndAllowThreads(__tstate);
48632 if (PyErr_Occurred()) SWIG_fail;
48633 }
48634 resultobj = SWIG_Py_Void();
48635 return resultobj;
48636 fail:
48637 return NULL;
48638 }
48639
48640
48641 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48642 PyObject *resultobj = 0;
48643 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48644 wxButton *result = 0 ;
48645 void *argp1 = 0 ;
48646 int res1 = 0 ;
48647 PyObject *swig_obj[1] ;
48648
48649 if (!args) SWIG_fail;
48650 swig_obj[0] = args;
48651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48652 if (!SWIG_IsOK(res1)) {
48653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48654 }
48655 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48656 {
48657 PyThreadState* __tstate = wxPyBeginAllowThreads();
48658 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48659 wxPyEndAllowThreads(__tstate);
48660 if (PyErr_Occurred()) SWIG_fail;
48661 }
48662 {
48663 resultobj = wxPyMake_wxObject(result, (bool)0);
48664 }
48665 return resultobj;
48666 fail:
48667 return NULL;
48668 }
48669
48670
48671 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48672 PyObject *resultobj = 0;
48673 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48674 wxButton *result = 0 ;
48675 void *argp1 = 0 ;
48676 int res1 = 0 ;
48677 PyObject *swig_obj[1] ;
48678
48679 if (!args) SWIG_fail;
48680 swig_obj[0] = args;
48681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48682 if (!SWIG_IsOK(res1)) {
48683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48684 }
48685 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48686 {
48687 PyThreadState* __tstate = wxPyBeginAllowThreads();
48688 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48689 wxPyEndAllowThreads(__tstate);
48690 if (PyErr_Occurred()) SWIG_fail;
48691 }
48692 {
48693 resultobj = wxPyMake_wxObject(result, (bool)0);
48694 }
48695 return resultobj;
48696 fail:
48697 return NULL;
48698 }
48699
48700
48701 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48702 PyObject *resultobj = 0;
48703 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48704 wxButton *result = 0 ;
48705 void *argp1 = 0 ;
48706 int res1 = 0 ;
48707 PyObject *swig_obj[1] ;
48708
48709 if (!args) SWIG_fail;
48710 swig_obj[0] = args;
48711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48712 if (!SWIG_IsOK(res1)) {
48713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48714 }
48715 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48716 {
48717 PyThreadState* __tstate = wxPyBeginAllowThreads();
48718 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48719 wxPyEndAllowThreads(__tstate);
48720 if (PyErr_Occurred()) SWIG_fail;
48721 }
48722 {
48723 resultobj = wxPyMake_wxObject(result, (bool)0);
48724 }
48725 return resultobj;
48726 fail:
48727 return NULL;
48728 }
48729
48730
48731 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48732 PyObject *resultobj = 0;
48733 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48734 wxButton *result = 0 ;
48735 void *argp1 = 0 ;
48736 int res1 = 0 ;
48737 PyObject *swig_obj[1] ;
48738
48739 if (!args) SWIG_fail;
48740 swig_obj[0] = args;
48741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48742 if (!SWIG_IsOK(res1)) {
48743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48744 }
48745 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48746 {
48747 PyThreadState* __tstate = wxPyBeginAllowThreads();
48748 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48749 wxPyEndAllowThreads(__tstate);
48750 if (PyErr_Occurred()) SWIG_fail;
48751 }
48752 {
48753 resultobj = wxPyMake_wxObject(result, (bool)0);
48754 }
48755 return resultobj;
48756 fail:
48757 return NULL;
48758 }
48759
48760
48761 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48762 PyObject *resultobj = 0;
48763 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48764 wxButton *result = 0 ;
48765 void *argp1 = 0 ;
48766 int res1 = 0 ;
48767 PyObject *swig_obj[1] ;
48768
48769 if (!args) SWIG_fail;
48770 swig_obj[0] = args;
48771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48772 if (!SWIG_IsOK(res1)) {
48773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48774 }
48775 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48776 {
48777 PyThreadState* __tstate = wxPyBeginAllowThreads();
48778 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48779 wxPyEndAllowThreads(__tstate);
48780 if (PyErr_Occurred()) SWIG_fail;
48781 }
48782 {
48783 resultobj = wxPyMake_wxObject(result, (bool)0);
48784 }
48785 return resultobj;
48786 fail:
48787 return NULL;
48788 }
48789
48790
48791 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48792 PyObject *obj;
48793 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48794 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48795 return SWIG_Py_Void();
48796 }
48797
48798 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48799 return SWIG_Python_InitShadowInstance(args);
48800 }
48801
48802 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48803 PyObject *resultobj = 0;
48804 int arg1 = (int) 0 ;
48805 int arg2 = (int) 0 ;
48806 wxGBPosition *result = 0 ;
48807 int val1 ;
48808 int ecode1 = 0 ;
48809 int val2 ;
48810 int ecode2 = 0 ;
48811 PyObject * obj0 = 0 ;
48812 PyObject * obj1 = 0 ;
48813 char * kwnames[] = {
48814 (char *) "row",(char *) "col", NULL
48815 };
48816
48817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48818 if (obj0) {
48819 ecode1 = SWIG_AsVal_int(obj0, &val1);
48820 if (!SWIG_IsOK(ecode1)) {
48821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48822 }
48823 arg1 = static_cast< int >(val1);
48824 }
48825 if (obj1) {
48826 ecode2 = SWIG_AsVal_int(obj1, &val2);
48827 if (!SWIG_IsOK(ecode2)) {
48828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48829 }
48830 arg2 = static_cast< int >(val2);
48831 }
48832 {
48833 PyThreadState* __tstate = wxPyBeginAllowThreads();
48834 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48835 wxPyEndAllowThreads(__tstate);
48836 if (PyErr_Occurred()) SWIG_fail;
48837 }
48838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48839 return resultobj;
48840 fail:
48841 return NULL;
48842 }
48843
48844
48845 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48846 PyObject *resultobj = 0;
48847 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48848 void *argp1 = 0 ;
48849 int res1 = 0 ;
48850 PyObject *swig_obj[1] ;
48851
48852 if (!args) SWIG_fail;
48853 swig_obj[0] = args;
48854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48855 if (!SWIG_IsOK(res1)) {
48856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48857 }
48858 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48859 {
48860 PyThreadState* __tstate = wxPyBeginAllowThreads();
48861 delete arg1;
48862
48863 wxPyEndAllowThreads(__tstate);
48864 if (PyErr_Occurred()) SWIG_fail;
48865 }
48866 resultobj = SWIG_Py_Void();
48867 return resultobj;
48868 fail:
48869 return NULL;
48870 }
48871
48872
48873 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48874 PyObject *resultobj = 0;
48875 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48876 int result;
48877 void *argp1 = 0 ;
48878 int res1 = 0 ;
48879 PyObject *swig_obj[1] ;
48880
48881 if (!args) SWIG_fail;
48882 swig_obj[0] = args;
48883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48884 if (!SWIG_IsOK(res1)) {
48885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48886 }
48887 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48888 {
48889 PyThreadState* __tstate = wxPyBeginAllowThreads();
48890 result = (int)((wxGBPosition const *)arg1)->GetRow();
48891 wxPyEndAllowThreads(__tstate);
48892 if (PyErr_Occurred()) SWIG_fail;
48893 }
48894 resultobj = SWIG_From_int(static_cast< int >(result));
48895 return resultobj;
48896 fail:
48897 return NULL;
48898 }
48899
48900
48901 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48902 PyObject *resultobj = 0;
48903 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48904 int result;
48905 void *argp1 = 0 ;
48906 int res1 = 0 ;
48907 PyObject *swig_obj[1] ;
48908
48909 if (!args) SWIG_fail;
48910 swig_obj[0] = args;
48911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48912 if (!SWIG_IsOK(res1)) {
48913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48914 }
48915 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48916 {
48917 PyThreadState* __tstate = wxPyBeginAllowThreads();
48918 result = (int)((wxGBPosition const *)arg1)->GetCol();
48919 wxPyEndAllowThreads(__tstate);
48920 if (PyErr_Occurred()) SWIG_fail;
48921 }
48922 resultobj = SWIG_From_int(static_cast< int >(result));
48923 return resultobj;
48924 fail:
48925 return NULL;
48926 }
48927
48928
48929 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48930 PyObject *resultobj = 0;
48931 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48932 int arg2 ;
48933 void *argp1 = 0 ;
48934 int res1 = 0 ;
48935 int val2 ;
48936 int ecode2 = 0 ;
48937 PyObject * obj0 = 0 ;
48938 PyObject * obj1 = 0 ;
48939 char * kwnames[] = {
48940 (char *) "self",(char *) "row", NULL
48941 };
48942
48943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48945 if (!SWIG_IsOK(res1)) {
48946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48947 }
48948 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48949 ecode2 = SWIG_AsVal_int(obj1, &val2);
48950 if (!SWIG_IsOK(ecode2)) {
48951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48952 }
48953 arg2 = static_cast< int >(val2);
48954 {
48955 PyThreadState* __tstate = wxPyBeginAllowThreads();
48956 (arg1)->SetRow(arg2);
48957 wxPyEndAllowThreads(__tstate);
48958 if (PyErr_Occurred()) SWIG_fail;
48959 }
48960 resultobj = SWIG_Py_Void();
48961 return resultobj;
48962 fail:
48963 return NULL;
48964 }
48965
48966
48967 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48968 PyObject *resultobj = 0;
48969 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48970 int arg2 ;
48971 void *argp1 = 0 ;
48972 int res1 = 0 ;
48973 int val2 ;
48974 int ecode2 = 0 ;
48975 PyObject * obj0 = 0 ;
48976 PyObject * obj1 = 0 ;
48977 char * kwnames[] = {
48978 (char *) "self",(char *) "col", NULL
48979 };
48980
48981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48983 if (!SWIG_IsOK(res1)) {
48984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48985 }
48986 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48987 ecode2 = SWIG_AsVal_int(obj1, &val2);
48988 if (!SWIG_IsOK(ecode2)) {
48989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48990 }
48991 arg2 = static_cast< int >(val2);
48992 {
48993 PyThreadState* __tstate = wxPyBeginAllowThreads();
48994 (arg1)->SetCol(arg2);
48995 wxPyEndAllowThreads(__tstate);
48996 if (PyErr_Occurred()) SWIG_fail;
48997 }
48998 resultobj = SWIG_Py_Void();
48999 return resultobj;
49000 fail:
49001 return NULL;
49002 }
49003
49004
49005 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49006 PyObject *resultobj = 0;
49007 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49008 PyObject *arg2 = (PyObject *) 0 ;
49009 bool result;
49010 void *argp1 = 0 ;
49011 int res1 = 0 ;
49012 PyObject * obj0 = 0 ;
49013 PyObject * obj1 = 0 ;
49014 char * kwnames[] = {
49015 (char *) "self",(char *) "other", NULL
49016 };
49017
49018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49020 if (!SWIG_IsOK(res1)) {
49021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49022 }
49023 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49024 arg2 = obj1;
49025 {
49026 result = (bool)wxGBPosition___eq__(arg1,arg2);
49027 if (PyErr_Occurred()) SWIG_fail;
49028 }
49029 {
49030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49031 }
49032 return resultobj;
49033 fail:
49034 return NULL;
49035 }
49036
49037
49038 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49039 PyObject *resultobj = 0;
49040 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49041 PyObject *arg2 = (PyObject *) 0 ;
49042 bool result;
49043 void *argp1 = 0 ;
49044 int res1 = 0 ;
49045 PyObject * obj0 = 0 ;
49046 PyObject * obj1 = 0 ;
49047 char * kwnames[] = {
49048 (char *) "self",(char *) "other", NULL
49049 };
49050
49051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49053 if (!SWIG_IsOK(res1)) {
49054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49055 }
49056 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49057 arg2 = obj1;
49058 {
49059 result = (bool)wxGBPosition___ne__(arg1,arg2);
49060 if (PyErr_Occurred()) SWIG_fail;
49061 }
49062 {
49063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49064 }
49065 return resultobj;
49066 fail:
49067 return NULL;
49068 }
49069
49070
49071 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49072 PyObject *resultobj = 0;
49073 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49074 int arg2 = (int) 0 ;
49075 int arg3 = (int) 0 ;
49076 void *argp1 = 0 ;
49077 int res1 = 0 ;
49078 int val2 ;
49079 int ecode2 = 0 ;
49080 int val3 ;
49081 int ecode3 = 0 ;
49082 PyObject * obj0 = 0 ;
49083 PyObject * obj1 = 0 ;
49084 PyObject * obj2 = 0 ;
49085 char * kwnames[] = {
49086 (char *) "self",(char *) "row",(char *) "col", NULL
49087 };
49088
49089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49091 if (!SWIG_IsOK(res1)) {
49092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49093 }
49094 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49095 if (obj1) {
49096 ecode2 = SWIG_AsVal_int(obj1, &val2);
49097 if (!SWIG_IsOK(ecode2)) {
49098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49099 }
49100 arg2 = static_cast< int >(val2);
49101 }
49102 if (obj2) {
49103 ecode3 = SWIG_AsVal_int(obj2, &val3);
49104 if (!SWIG_IsOK(ecode3)) {
49105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49106 }
49107 arg3 = static_cast< int >(val3);
49108 }
49109 {
49110 PyThreadState* __tstate = wxPyBeginAllowThreads();
49111 wxGBPosition_Set(arg1,arg2,arg3);
49112 wxPyEndAllowThreads(__tstate);
49113 if (PyErr_Occurred()) SWIG_fail;
49114 }
49115 resultobj = SWIG_Py_Void();
49116 return resultobj;
49117 fail:
49118 return NULL;
49119 }
49120
49121
49122 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49123 PyObject *resultobj = 0;
49124 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49125 PyObject *result = 0 ;
49126 void *argp1 = 0 ;
49127 int res1 = 0 ;
49128 PyObject *swig_obj[1] ;
49129
49130 if (!args) SWIG_fail;
49131 swig_obj[0] = args;
49132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49133 if (!SWIG_IsOK(res1)) {
49134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49135 }
49136 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49137 {
49138 PyThreadState* __tstate = wxPyBeginAllowThreads();
49139 result = (PyObject *)wxGBPosition_Get(arg1);
49140 wxPyEndAllowThreads(__tstate);
49141 if (PyErr_Occurred()) SWIG_fail;
49142 }
49143 resultobj = result;
49144 return resultobj;
49145 fail:
49146 return NULL;
49147 }
49148
49149
49150 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49151 PyObject *obj;
49152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49153 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49154 return SWIG_Py_Void();
49155 }
49156
49157 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49158 return SWIG_Python_InitShadowInstance(args);
49159 }
49160
49161 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49162 PyObject *resultobj = 0;
49163 int arg1 = (int) 1 ;
49164 int arg2 = (int) 1 ;
49165 wxGBSpan *result = 0 ;
49166 int val1 ;
49167 int ecode1 = 0 ;
49168 int val2 ;
49169 int ecode2 = 0 ;
49170 PyObject * obj0 = 0 ;
49171 PyObject * obj1 = 0 ;
49172 char * kwnames[] = {
49173 (char *) "rowspan",(char *) "colspan", NULL
49174 };
49175
49176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49177 if (obj0) {
49178 ecode1 = SWIG_AsVal_int(obj0, &val1);
49179 if (!SWIG_IsOK(ecode1)) {
49180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49181 }
49182 arg1 = static_cast< int >(val1);
49183 }
49184 if (obj1) {
49185 ecode2 = SWIG_AsVal_int(obj1, &val2);
49186 if (!SWIG_IsOK(ecode2)) {
49187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49188 }
49189 arg2 = static_cast< int >(val2);
49190 }
49191 {
49192 PyThreadState* __tstate = wxPyBeginAllowThreads();
49193 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49194 wxPyEndAllowThreads(__tstate);
49195 if (PyErr_Occurred()) SWIG_fail;
49196 }
49197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49198 return resultobj;
49199 fail:
49200 return NULL;
49201 }
49202
49203
49204 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49205 PyObject *resultobj = 0;
49206 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49207 void *argp1 = 0 ;
49208 int res1 = 0 ;
49209 PyObject *swig_obj[1] ;
49210
49211 if (!args) SWIG_fail;
49212 swig_obj[0] = args;
49213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49214 if (!SWIG_IsOK(res1)) {
49215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49216 }
49217 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49218 {
49219 PyThreadState* __tstate = wxPyBeginAllowThreads();
49220 delete arg1;
49221
49222 wxPyEndAllowThreads(__tstate);
49223 if (PyErr_Occurred()) SWIG_fail;
49224 }
49225 resultobj = SWIG_Py_Void();
49226 return resultobj;
49227 fail:
49228 return NULL;
49229 }
49230
49231
49232 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49233 PyObject *resultobj = 0;
49234 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49235 int result;
49236 void *argp1 = 0 ;
49237 int res1 = 0 ;
49238 PyObject *swig_obj[1] ;
49239
49240 if (!args) SWIG_fail;
49241 swig_obj[0] = args;
49242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49243 if (!SWIG_IsOK(res1)) {
49244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49245 }
49246 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49247 {
49248 PyThreadState* __tstate = wxPyBeginAllowThreads();
49249 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49250 wxPyEndAllowThreads(__tstate);
49251 if (PyErr_Occurred()) SWIG_fail;
49252 }
49253 resultobj = SWIG_From_int(static_cast< int >(result));
49254 return resultobj;
49255 fail:
49256 return NULL;
49257 }
49258
49259
49260 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49261 PyObject *resultobj = 0;
49262 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49263 int result;
49264 void *argp1 = 0 ;
49265 int res1 = 0 ;
49266 PyObject *swig_obj[1] ;
49267
49268 if (!args) SWIG_fail;
49269 swig_obj[0] = args;
49270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49271 if (!SWIG_IsOK(res1)) {
49272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49273 }
49274 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49275 {
49276 PyThreadState* __tstate = wxPyBeginAllowThreads();
49277 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49278 wxPyEndAllowThreads(__tstate);
49279 if (PyErr_Occurred()) SWIG_fail;
49280 }
49281 resultobj = SWIG_From_int(static_cast< int >(result));
49282 return resultobj;
49283 fail:
49284 return NULL;
49285 }
49286
49287
49288 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49289 PyObject *resultobj = 0;
49290 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49291 int arg2 ;
49292 void *argp1 = 0 ;
49293 int res1 = 0 ;
49294 int val2 ;
49295 int ecode2 = 0 ;
49296 PyObject * obj0 = 0 ;
49297 PyObject * obj1 = 0 ;
49298 char * kwnames[] = {
49299 (char *) "self",(char *) "rowspan", NULL
49300 };
49301
49302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49304 if (!SWIG_IsOK(res1)) {
49305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49306 }
49307 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49308 ecode2 = SWIG_AsVal_int(obj1, &val2);
49309 if (!SWIG_IsOK(ecode2)) {
49310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49311 }
49312 arg2 = static_cast< int >(val2);
49313 {
49314 PyThreadState* __tstate = wxPyBeginAllowThreads();
49315 (arg1)->SetRowspan(arg2);
49316 wxPyEndAllowThreads(__tstate);
49317 if (PyErr_Occurred()) SWIG_fail;
49318 }
49319 resultobj = SWIG_Py_Void();
49320 return resultobj;
49321 fail:
49322 return NULL;
49323 }
49324
49325
49326 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49327 PyObject *resultobj = 0;
49328 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49329 int arg2 ;
49330 void *argp1 = 0 ;
49331 int res1 = 0 ;
49332 int val2 ;
49333 int ecode2 = 0 ;
49334 PyObject * obj0 = 0 ;
49335 PyObject * obj1 = 0 ;
49336 char * kwnames[] = {
49337 (char *) "self",(char *) "colspan", NULL
49338 };
49339
49340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49342 if (!SWIG_IsOK(res1)) {
49343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49344 }
49345 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49346 ecode2 = SWIG_AsVal_int(obj1, &val2);
49347 if (!SWIG_IsOK(ecode2)) {
49348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49349 }
49350 arg2 = static_cast< int >(val2);
49351 {
49352 PyThreadState* __tstate = wxPyBeginAllowThreads();
49353 (arg1)->SetColspan(arg2);
49354 wxPyEndAllowThreads(__tstate);
49355 if (PyErr_Occurred()) SWIG_fail;
49356 }
49357 resultobj = SWIG_Py_Void();
49358 return resultobj;
49359 fail:
49360 return NULL;
49361 }
49362
49363
49364 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49365 PyObject *resultobj = 0;
49366 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49367 PyObject *arg2 = (PyObject *) 0 ;
49368 bool result;
49369 void *argp1 = 0 ;
49370 int res1 = 0 ;
49371 PyObject * obj0 = 0 ;
49372 PyObject * obj1 = 0 ;
49373 char * kwnames[] = {
49374 (char *) "self",(char *) "other", NULL
49375 };
49376
49377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49379 if (!SWIG_IsOK(res1)) {
49380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49381 }
49382 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49383 arg2 = obj1;
49384 {
49385 result = (bool)wxGBSpan___eq__(arg1,arg2);
49386 if (PyErr_Occurred()) SWIG_fail;
49387 }
49388 {
49389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49390 }
49391 return resultobj;
49392 fail:
49393 return NULL;
49394 }
49395
49396
49397 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49398 PyObject *resultobj = 0;
49399 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49400 PyObject *arg2 = (PyObject *) 0 ;
49401 bool result;
49402 void *argp1 = 0 ;
49403 int res1 = 0 ;
49404 PyObject * obj0 = 0 ;
49405 PyObject * obj1 = 0 ;
49406 char * kwnames[] = {
49407 (char *) "self",(char *) "other", NULL
49408 };
49409
49410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49412 if (!SWIG_IsOK(res1)) {
49413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49414 }
49415 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49416 arg2 = obj1;
49417 {
49418 result = (bool)wxGBSpan___ne__(arg1,arg2);
49419 if (PyErr_Occurred()) SWIG_fail;
49420 }
49421 {
49422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49423 }
49424 return resultobj;
49425 fail:
49426 return NULL;
49427 }
49428
49429
49430 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49431 PyObject *resultobj = 0;
49432 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49433 int arg2 = (int) 1 ;
49434 int arg3 = (int) 1 ;
49435 void *argp1 = 0 ;
49436 int res1 = 0 ;
49437 int val2 ;
49438 int ecode2 = 0 ;
49439 int val3 ;
49440 int ecode3 = 0 ;
49441 PyObject * obj0 = 0 ;
49442 PyObject * obj1 = 0 ;
49443 PyObject * obj2 = 0 ;
49444 char * kwnames[] = {
49445 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49446 };
49447
49448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49450 if (!SWIG_IsOK(res1)) {
49451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49452 }
49453 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49454 if (obj1) {
49455 ecode2 = SWIG_AsVal_int(obj1, &val2);
49456 if (!SWIG_IsOK(ecode2)) {
49457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49458 }
49459 arg2 = static_cast< int >(val2);
49460 }
49461 if (obj2) {
49462 ecode3 = SWIG_AsVal_int(obj2, &val3);
49463 if (!SWIG_IsOK(ecode3)) {
49464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49465 }
49466 arg3 = static_cast< int >(val3);
49467 }
49468 {
49469 PyThreadState* __tstate = wxPyBeginAllowThreads();
49470 wxGBSpan_Set(arg1,arg2,arg3);
49471 wxPyEndAllowThreads(__tstate);
49472 if (PyErr_Occurred()) SWIG_fail;
49473 }
49474 resultobj = SWIG_Py_Void();
49475 return resultobj;
49476 fail:
49477 return NULL;
49478 }
49479
49480
49481 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49482 PyObject *resultobj = 0;
49483 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49484 PyObject *result = 0 ;
49485 void *argp1 = 0 ;
49486 int res1 = 0 ;
49487 PyObject *swig_obj[1] ;
49488
49489 if (!args) SWIG_fail;
49490 swig_obj[0] = args;
49491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49492 if (!SWIG_IsOK(res1)) {
49493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49494 }
49495 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49496 {
49497 PyThreadState* __tstate = wxPyBeginAllowThreads();
49498 result = (PyObject *)wxGBSpan_Get(arg1);
49499 wxPyEndAllowThreads(__tstate);
49500 if (PyErr_Occurred()) SWIG_fail;
49501 }
49502 resultobj = result;
49503 return resultobj;
49504 fail:
49505 return NULL;
49506 }
49507
49508
49509 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49510 PyObject *obj;
49511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49512 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49513 return SWIG_Py_Void();
49514 }
49515
49516 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49517 return SWIG_Python_InitShadowInstance(args);
49518 }
49519
49520 SWIGINTERN int DefaultSpan_set(PyObject *) {
49521 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49522 return 1;
49523 }
49524
49525
49526 SWIGINTERN PyObject *DefaultSpan_get(void) {
49527 PyObject *pyobj = 0;
49528
49529 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49530 return pyobj;
49531 }
49532
49533
49534 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49535 PyObject *resultobj = 0;
49536 wxGBSizerItem *result = 0 ;
49537
49538 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49539 {
49540 PyThreadState* __tstate = wxPyBeginAllowThreads();
49541 result = (wxGBSizerItem *)new wxGBSizerItem();
49542 wxPyEndAllowThreads(__tstate);
49543 if (PyErr_Occurred()) SWIG_fail;
49544 }
49545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49546 return resultobj;
49547 fail:
49548 return NULL;
49549 }
49550
49551
49552 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49553 PyObject *resultobj = 0;
49554 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49555 void *argp1 = 0 ;
49556 int res1 = 0 ;
49557 PyObject *swig_obj[1] ;
49558
49559 if (!args) SWIG_fail;
49560 swig_obj[0] = args;
49561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49562 if (!SWIG_IsOK(res1)) {
49563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49564 }
49565 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49566 {
49567 PyThreadState* __tstate = wxPyBeginAllowThreads();
49568 delete arg1;
49569
49570 wxPyEndAllowThreads(__tstate);
49571 if (PyErr_Occurred()) SWIG_fail;
49572 }
49573 resultobj = SWIG_Py_Void();
49574 return resultobj;
49575 fail:
49576 return NULL;
49577 }
49578
49579
49580 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49581 PyObject *resultobj = 0;
49582 wxWindow *arg1 = (wxWindow *) 0 ;
49583 wxGBPosition *arg2 = 0 ;
49584 wxGBSpan *arg3 = 0 ;
49585 int arg4 ;
49586 int arg5 ;
49587 PyObject *arg6 = (PyObject *) NULL ;
49588 wxGBSizerItem *result = 0 ;
49589 void *argp1 = 0 ;
49590 int res1 = 0 ;
49591 wxGBPosition temp2 ;
49592 wxGBSpan temp3 ;
49593 int val4 ;
49594 int ecode4 = 0 ;
49595 int val5 ;
49596 int ecode5 = 0 ;
49597 PyObject * obj0 = 0 ;
49598 PyObject * obj1 = 0 ;
49599 PyObject * obj2 = 0 ;
49600 PyObject * obj3 = 0 ;
49601 PyObject * obj4 = 0 ;
49602 PyObject * obj5 = 0 ;
49603 char * kwnames[] = {
49604 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49605 };
49606
49607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49609 if (!SWIG_IsOK(res1)) {
49610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49611 }
49612 arg1 = reinterpret_cast< wxWindow * >(argp1);
49613 {
49614 arg2 = &temp2;
49615 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49616 }
49617 {
49618 arg3 = &temp3;
49619 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49620 }
49621 ecode4 = SWIG_AsVal_int(obj3, &val4);
49622 if (!SWIG_IsOK(ecode4)) {
49623 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49624 }
49625 arg4 = static_cast< int >(val4);
49626 ecode5 = SWIG_AsVal_int(obj4, &val5);
49627 if (!SWIG_IsOK(ecode5)) {
49628 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49629 }
49630 arg5 = static_cast< int >(val5);
49631 if (obj5) {
49632 arg6 = obj5;
49633 }
49634 {
49635 PyThreadState* __tstate = wxPyBeginAllowThreads();
49636 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49637 wxPyEndAllowThreads(__tstate);
49638 if (PyErr_Occurred()) SWIG_fail;
49639 }
49640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49641 return resultobj;
49642 fail:
49643 return NULL;
49644 }
49645
49646
49647 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49648 PyObject *resultobj = 0;
49649 wxSizer *arg1 = (wxSizer *) 0 ;
49650 wxGBPosition *arg2 = 0 ;
49651 wxGBSpan *arg3 = 0 ;
49652 int arg4 ;
49653 int arg5 ;
49654 PyObject *arg6 = (PyObject *) NULL ;
49655 wxGBSizerItem *result = 0 ;
49656 int res1 = 0 ;
49657 wxGBPosition temp2 ;
49658 wxGBSpan temp3 ;
49659 int val4 ;
49660 int ecode4 = 0 ;
49661 int val5 ;
49662 int ecode5 = 0 ;
49663 PyObject * obj0 = 0 ;
49664 PyObject * obj1 = 0 ;
49665 PyObject * obj2 = 0 ;
49666 PyObject * obj3 = 0 ;
49667 PyObject * obj4 = 0 ;
49668 PyObject * obj5 = 0 ;
49669 char * kwnames[] = {
49670 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49671 };
49672
49673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49674 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49675 if (!SWIG_IsOK(res1)) {
49676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49677 }
49678 {
49679 arg2 = &temp2;
49680 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49681 }
49682 {
49683 arg3 = &temp3;
49684 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49685 }
49686 ecode4 = SWIG_AsVal_int(obj3, &val4);
49687 if (!SWIG_IsOK(ecode4)) {
49688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49689 }
49690 arg4 = static_cast< int >(val4);
49691 ecode5 = SWIG_AsVal_int(obj4, &val5);
49692 if (!SWIG_IsOK(ecode5)) {
49693 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49694 }
49695 arg5 = static_cast< int >(val5);
49696 if (obj5) {
49697 arg6 = obj5;
49698 }
49699 {
49700 PyThreadState* __tstate = wxPyBeginAllowThreads();
49701 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49702 wxPyEndAllowThreads(__tstate);
49703 if (PyErr_Occurred()) SWIG_fail;
49704 }
49705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49706 return resultobj;
49707 fail:
49708 return NULL;
49709 }
49710
49711
49712 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49713 PyObject *resultobj = 0;
49714 int arg1 ;
49715 int arg2 ;
49716 wxGBPosition *arg3 = 0 ;
49717 wxGBSpan *arg4 = 0 ;
49718 int arg5 ;
49719 int arg6 ;
49720 PyObject *arg7 = (PyObject *) NULL ;
49721 wxGBSizerItem *result = 0 ;
49722 int val1 ;
49723 int ecode1 = 0 ;
49724 int val2 ;
49725 int ecode2 = 0 ;
49726 wxGBPosition temp3 ;
49727 wxGBSpan temp4 ;
49728 int val5 ;
49729 int ecode5 = 0 ;
49730 int val6 ;
49731 int ecode6 = 0 ;
49732 PyObject * obj0 = 0 ;
49733 PyObject * obj1 = 0 ;
49734 PyObject * obj2 = 0 ;
49735 PyObject * obj3 = 0 ;
49736 PyObject * obj4 = 0 ;
49737 PyObject * obj5 = 0 ;
49738 PyObject * obj6 = 0 ;
49739 char * kwnames[] = {
49740 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49741 };
49742
49743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49744 ecode1 = SWIG_AsVal_int(obj0, &val1);
49745 if (!SWIG_IsOK(ecode1)) {
49746 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49747 }
49748 arg1 = static_cast< int >(val1);
49749 ecode2 = SWIG_AsVal_int(obj1, &val2);
49750 if (!SWIG_IsOK(ecode2)) {
49751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49752 }
49753 arg2 = static_cast< int >(val2);
49754 {
49755 arg3 = &temp3;
49756 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49757 }
49758 {
49759 arg4 = &temp4;
49760 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49761 }
49762 ecode5 = SWIG_AsVal_int(obj4, &val5);
49763 if (!SWIG_IsOK(ecode5)) {
49764 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49765 }
49766 arg5 = static_cast< int >(val5);
49767 ecode6 = SWIG_AsVal_int(obj5, &val6);
49768 if (!SWIG_IsOK(ecode6)) {
49769 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49770 }
49771 arg6 = static_cast< int >(val6);
49772 if (obj6) {
49773 arg7 = obj6;
49774 }
49775 {
49776 PyThreadState* __tstate = wxPyBeginAllowThreads();
49777 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49778 wxPyEndAllowThreads(__tstate);
49779 if (PyErr_Occurred()) SWIG_fail;
49780 }
49781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49782 return resultobj;
49783 fail:
49784 return NULL;
49785 }
49786
49787
49788 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49789 PyObject *resultobj = 0;
49790 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49791 wxGBPosition result;
49792 void *argp1 = 0 ;
49793 int res1 = 0 ;
49794 PyObject *swig_obj[1] ;
49795
49796 if (!args) SWIG_fail;
49797 swig_obj[0] = args;
49798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49799 if (!SWIG_IsOK(res1)) {
49800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49801 }
49802 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49803 {
49804 PyThreadState* __tstate = wxPyBeginAllowThreads();
49805 result = ((wxGBSizerItem const *)arg1)->GetPos();
49806 wxPyEndAllowThreads(__tstate);
49807 if (PyErr_Occurred()) SWIG_fail;
49808 }
49809 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49810 return resultobj;
49811 fail:
49812 return NULL;
49813 }
49814
49815
49816 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49817 PyObject *resultobj = 0;
49818 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49819 wxGBSpan result;
49820 void *argp1 = 0 ;
49821 int res1 = 0 ;
49822 PyObject *swig_obj[1] ;
49823
49824 if (!args) SWIG_fail;
49825 swig_obj[0] = args;
49826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49827 if (!SWIG_IsOK(res1)) {
49828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49829 }
49830 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49831 {
49832 PyThreadState* __tstate = wxPyBeginAllowThreads();
49833 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49834 wxPyEndAllowThreads(__tstate);
49835 if (PyErr_Occurred()) SWIG_fail;
49836 }
49837 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49838 return resultobj;
49839 fail:
49840 return NULL;
49841 }
49842
49843
49844 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49845 PyObject *resultobj = 0;
49846 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49847 wxGBPosition *arg2 = 0 ;
49848 bool result;
49849 void *argp1 = 0 ;
49850 int res1 = 0 ;
49851 wxGBPosition temp2 ;
49852 PyObject * obj0 = 0 ;
49853 PyObject * obj1 = 0 ;
49854 char * kwnames[] = {
49855 (char *) "self",(char *) "pos", NULL
49856 };
49857
49858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49860 if (!SWIG_IsOK(res1)) {
49861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49862 }
49863 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49864 {
49865 arg2 = &temp2;
49866 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49867 }
49868 {
49869 PyThreadState* __tstate = wxPyBeginAllowThreads();
49870 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49871 wxPyEndAllowThreads(__tstate);
49872 if (PyErr_Occurred()) SWIG_fail;
49873 }
49874 {
49875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49876 }
49877 return resultobj;
49878 fail:
49879 return NULL;
49880 }
49881
49882
49883 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49884 PyObject *resultobj = 0;
49885 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49886 wxGBSpan *arg2 = 0 ;
49887 bool result;
49888 void *argp1 = 0 ;
49889 int res1 = 0 ;
49890 wxGBSpan temp2 ;
49891 PyObject * obj0 = 0 ;
49892 PyObject * obj1 = 0 ;
49893 char * kwnames[] = {
49894 (char *) "self",(char *) "span", NULL
49895 };
49896
49897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49899 if (!SWIG_IsOK(res1)) {
49900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49901 }
49902 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49903 {
49904 arg2 = &temp2;
49905 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49906 }
49907 {
49908 PyThreadState* __tstate = wxPyBeginAllowThreads();
49909 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49910 wxPyEndAllowThreads(__tstate);
49911 if (PyErr_Occurred()) SWIG_fail;
49912 }
49913 {
49914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49915 }
49916 return resultobj;
49917 fail:
49918 return NULL;
49919 }
49920
49921
49922 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49923 PyObject *resultobj = 0;
49924 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49925 wxGBSizerItem *arg2 = 0 ;
49926 bool result;
49927 void *argp1 = 0 ;
49928 int res1 = 0 ;
49929 void *argp2 = 0 ;
49930 int res2 = 0 ;
49931 PyObject * obj0 = 0 ;
49932 PyObject * obj1 = 0 ;
49933 char * kwnames[] = {
49934 (char *) "self",(char *) "other", NULL
49935 };
49936
49937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49939 if (!SWIG_IsOK(res1)) {
49940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49941 }
49942 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49943 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49944 if (!SWIG_IsOK(res2)) {
49945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49946 }
49947 if (!argp2) {
49948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49949 }
49950 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49951 {
49952 PyThreadState* __tstate = wxPyBeginAllowThreads();
49953 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49954 wxPyEndAllowThreads(__tstate);
49955 if (PyErr_Occurred()) SWIG_fail;
49956 }
49957 {
49958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49959 }
49960 return resultobj;
49961 fail:
49962 return NULL;
49963 }
49964
49965
49966 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49967 PyObject *resultobj = 0;
49968 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49969 wxGBPosition *arg2 = 0 ;
49970 wxGBSpan *arg3 = 0 ;
49971 bool result;
49972 void *argp1 = 0 ;
49973 int res1 = 0 ;
49974 wxGBPosition temp2 ;
49975 wxGBSpan temp3 ;
49976 PyObject * obj0 = 0 ;
49977 PyObject * obj1 = 0 ;
49978 PyObject * obj2 = 0 ;
49979 char * kwnames[] = {
49980 (char *) "self",(char *) "pos",(char *) "span", NULL
49981 };
49982
49983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49985 if (!SWIG_IsOK(res1)) {
49986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49987 }
49988 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49989 {
49990 arg2 = &temp2;
49991 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49992 }
49993 {
49994 arg3 = &temp3;
49995 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49996 }
49997 {
49998 PyThreadState* __tstate = wxPyBeginAllowThreads();
49999 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50000 wxPyEndAllowThreads(__tstate);
50001 if (PyErr_Occurred()) SWIG_fail;
50002 }
50003 {
50004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50005 }
50006 return resultobj;
50007 fail:
50008 return NULL;
50009 }
50010
50011
50012 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50013 PyObject *resultobj = 0;
50014 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50015 wxGBPosition result;
50016 void *argp1 = 0 ;
50017 int res1 = 0 ;
50018 PyObject *swig_obj[1] ;
50019
50020 if (!args) SWIG_fail;
50021 swig_obj[0] = args;
50022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50023 if (!SWIG_IsOK(res1)) {
50024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50025 }
50026 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50027 {
50028 PyThreadState* __tstate = wxPyBeginAllowThreads();
50029 result = wxGBSizerItem_GetEndPos(arg1);
50030 wxPyEndAllowThreads(__tstate);
50031 if (PyErr_Occurred()) SWIG_fail;
50032 }
50033 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50034 return resultobj;
50035 fail:
50036 return NULL;
50037 }
50038
50039
50040 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50041 PyObject *resultobj = 0;
50042 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50043 wxGridBagSizer *result = 0 ;
50044 void *argp1 = 0 ;
50045 int res1 = 0 ;
50046 PyObject *swig_obj[1] ;
50047
50048 if (!args) SWIG_fail;
50049 swig_obj[0] = args;
50050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50051 if (!SWIG_IsOK(res1)) {
50052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50053 }
50054 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50055 {
50056 PyThreadState* __tstate = wxPyBeginAllowThreads();
50057 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50058 wxPyEndAllowThreads(__tstate);
50059 if (PyErr_Occurred()) SWIG_fail;
50060 }
50061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50062 return resultobj;
50063 fail:
50064 return NULL;
50065 }
50066
50067
50068 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50069 PyObject *resultobj = 0;
50070 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50071 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50072 void *argp1 = 0 ;
50073 int res1 = 0 ;
50074 void *argp2 = 0 ;
50075 int res2 = 0 ;
50076 PyObject * obj0 = 0 ;
50077 PyObject * obj1 = 0 ;
50078 char * kwnames[] = {
50079 (char *) "self",(char *) "sizer", NULL
50080 };
50081
50082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50084 if (!SWIG_IsOK(res1)) {
50085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50086 }
50087 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50088 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50089 if (!SWIG_IsOK(res2)) {
50090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50091 }
50092 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50093 {
50094 PyThreadState* __tstate = wxPyBeginAllowThreads();
50095 (arg1)->SetGBSizer(arg2);
50096 wxPyEndAllowThreads(__tstate);
50097 if (PyErr_Occurred()) SWIG_fail;
50098 }
50099 resultobj = SWIG_Py_Void();
50100 return resultobj;
50101 fail:
50102 return NULL;
50103 }
50104
50105
50106 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50107 PyObject *obj;
50108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50109 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50110 return SWIG_Py_Void();
50111 }
50112
50113 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50114 return SWIG_Python_InitShadowInstance(args);
50115 }
50116
50117 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50118 PyObject *resultobj = 0;
50119 int arg1 = (int) 0 ;
50120 int arg2 = (int) 0 ;
50121 wxGridBagSizer *result = 0 ;
50122 int val1 ;
50123 int ecode1 = 0 ;
50124 int val2 ;
50125 int ecode2 = 0 ;
50126 PyObject * obj0 = 0 ;
50127 PyObject * obj1 = 0 ;
50128 char * kwnames[] = {
50129 (char *) "vgap",(char *) "hgap", NULL
50130 };
50131
50132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50133 if (obj0) {
50134 ecode1 = SWIG_AsVal_int(obj0, &val1);
50135 if (!SWIG_IsOK(ecode1)) {
50136 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50137 }
50138 arg1 = static_cast< int >(val1);
50139 }
50140 if (obj1) {
50141 ecode2 = SWIG_AsVal_int(obj1, &val2);
50142 if (!SWIG_IsOK(ecode2)) {
50143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50144 }
50145 arg2 = static_cast< int >(val2);
50146 }
50147 {
50148 PyThreadState* __tstate = wxPyBeginAllowThreads();
50149 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50150 wxPyEndAllowThreads(__tstate);
50151 if (PyErr_Occurred()) SWIG_fail;
50152 }
50153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50154 return resultobj;
50155 fail:
50156 return NULL;
50157 }
50158
50159
50160 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50161 PyObject *resultobj = 0;
50162 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50163 PyObject *arg2 = (PyObject *) 0 ;
50164 wxGBPosition *arg3 = 0 ;
50165 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50166 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50167 int arg5 = (int) 0 ;
50168 int arg6 = (int) 0 ;
50169 PyObject *arg7 = (PyObject *) NULL ;
50170 wxGBSizerItem *result = 0 ;
50171 void *argp1 = 0 ;
50172 int res1 = 0 ;
50173 wxGBPosition temp3 ;
50174 wxGBSpan temp4 ;
50175 int val5 ;
50176 int ecode5 = 0 ;
50177 int val6 ;
50178 int ecode6 = 0 ;
50179 PyObject * obj0 = 0 ;
50180 PyObject * obj1 = 0 ;
50181 PyObject * obj2 = 0 ;
50182 PyObject * obj3 = 0 ;
50183 PyObject * obj4 = 0 ;
50184 PyObject * obj5 = 0 ;
50185 PyObject * obj6 = 0 ;
50186 char * kwnames[] = {
50187 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50188 };
50189
50190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50192 if (!SWIG_IsOK(res1)) {
50193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50194 }
50195 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50196 arg2 = obj1;
50197 {
50198 arg3 = &temp3;
50199 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50200 }
50201 if (obj3) {
50202 {
50203 arg4 = &temp4;
50204 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50205 }
50206 }
50207 if (obj4) {
50208 ecode5 = SWIG_AsVal_int(obj4, &val5);
50209 if (!SWIG_IsOK(ecode5)) {
50210 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50211 }
50212 arg5 = static_cast< int >(val5);
50213 }
50214 if (obj5) {
50215 ecode6 = SWIG_AsVal_int(obj5, &val6);
50216 if (!SWIG_IsOK(ecode6)) {
50217 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50218 }
50219 arg6 = static_cast< int >(val6);
50220 }
50221 if (obj6) {
50222 arg7 = obj6;
50223 }
50224 {
50225 PyThreadState* __tstate = wxPyBeginAllowThreads();
50226 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50227 wxPyEndAllowThreads(__tstate);
50228 if (PyErr_Occurred()) SWIG_fail;
50229 }
50230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50231 return resultobj;
50232 fail:
50233 return NULL;
50234 }
50235
50236
50237 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50238 PyObject *resultobj = 0;
50239 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50240 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50241 wxGBSizerItem *result = 0 ;
50242 void *argp1 = 0 ;
50243 int res1 = 0 ;
50244 int res2 = 0 ;
50245 PyObject * obj0 = 0 ;
50246 PyObject * obj1 = 0 ;
50247 char * kwnames[] = {
50248 (char *) "self",(char *) "item", NULL
50249 };
50250
50251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50253 if (!SWIG_IsOK(res1)) {
50254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50255 }
50256 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50257 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50258 if (!SWIG_IsOK(res2)) {
50259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50260 }
50261 {
50262 PyThreadState* __tstate = wxPyBeginAllowThreads();
50263 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50264 wxPyEndAllowThreads(__tstate);
50265 if (PyErr_Occurred()) SWIG_fail;
50266 }
50267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50268 return resultobj;
50269 fail:
50270 return NULL;
50271 }
50272
50273
50274 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50275 PyObject *resultobj = 0;
50276 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50277 int arg2 ;
50278 int arg3 ;
50279 wxSize result;
50280 void *argp1 = 0 ;
50281 int res1 = 0 ;
50282 int val2 ;
50283 int ecode2 = 0 ;
50284 int val3 ;
50285 int ecode3 = 0 ;
50286 PyObject * obj0 = 0 ;
50287 PyObject * obj1 = 0 ;
50288 PyObject * obj2 = 0 ;
50289 char * kwnames[] = {
50290 (char *) "self",(char *) "row",(char *) "col", NULL
50291 };
50292
50293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50295 if (!SWIG_IsOK(res1)) {
50296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50297 }
50298 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50299 ecode2 = SWIG_AsVal_int(obj1, &val2);
50300 if (!SWIG_IsOK(ecode2)) {
50301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50302 }
50303 arg2 = static_cast< int >(val2);
50304 ecode3 = SWIG_AsVal_int(obj2, &val3);
50305 if (!SWIG_IsOK(ecode3)) {
50306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50307 }
50308 arg3 = static_cast< int >(val3);
50309 {
50310 PyThreadState* __tstate = wxPyBeginAllowThreads();
50311 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50312 wxPyEndAllowThreads(__tstate);
50313 if (PyErr_Occurred()) SWIG_fail;
50314 }
50315 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50316 return resultobj;
50317 fail:
50318 return NULL;
50319 }
50320
50321
50322 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50323 PyObject *resultobj = 0;
50324 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50325 wxSize result;
50326 void *argp1 = 0 ;
50327 int res1 = 0 ;
50328 PyObject *swig_obj[1] ;
50329
50330 if (!args) SWIG_fail;
50331 swig_obj[0] = args;
50332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50333 if (!SWIG_IsOK(res1)) {
50334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50335 }
50336 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50337 {
50338 PyThreadState* __tstate = wxPyBeginAllowThreads();
50339 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50340 wxPyEndAllowThreads(__tstate);
50341 if (PyErr_Occurred()) SWIG_fail;
50342 }
50343 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50344 return resultobj;
50345 fail:
50346 return NULL;
50347 }
50348
50349
50350 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50351 PyObject *resultobj = 0;
50352 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50353 wxSize *arg2 = 0 ;
50354 void *argp1 = 0 ;
50355 int res1 = 0 ;
50356 wxSize temp2 ;
50357 PyObject * obj0 = 0 ;
50358 PyObject * obj1 = 0 ;
50359 char * kwnames[] = {
50360 (char *) "self",(char *) "sz", NULL
50361 };
50362
50363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50365 if (!SWIG_IsOK(res1)) {
50366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50367 }
50368 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50369 {
50370 arg2 = &temp2;
50371 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50372 }
50373 {
50374 PyThreadState* __tstate = wxPyBeginAllowThreads();
50375 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50376 wxPyEndAllowThreads(__tstate);
50377 if (PyErr_Occurred()) SWIG_fail;
50378 }
50379 resultobj = SWIG_Py_Void();
50380 return resultobj;
50381 fail:
50382 return NULL;
50383 }
50384
50385
50386 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50387 PyObject *resultobj = 0;
50388 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50389 wxWindow *arg2 = (wxWindow *) 0 ;
50390 wxGBPosition result;
50391 void *argp1 = 0 ;
50392 int res1 = 0 ;
50393 void *argp2 = 0 ;
50394 int res2 = 0 ;
50395
50396 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50398 if (!SWIG_IsOK(res1)) {
50399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50400 }
50401 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50402 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50403 if (!SWIG_IsOK(res2)) {
50404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50405 }
50406 arg2 = reinterpret_cast< wxWindow * >(argp2);
50407 {
50408 PyThreadState* __tstate = wxPyBeginAllowThreads();
50409 result = (arg1)->GetItemPosition(arg2);
50410 wxPyEndAllowThreads(__tstate);
50411 if (PyErr_Occurred()) SWIG_fail;
50412 }
50413 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50414 return resultobj;
50415 fail:
50416 return NULL;
50417 }
50418
50419
50420 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50421 PyObject *resultobj = 0;
50422 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50423 wxSizer *arg2 = (wxSizer *) 0 ;
50424 wxGBPosition result;
50425 void *argp1 = 0 ;
50426 int res1 = 0 ;
50427 void *argp2 = 0 ;
50428 int res2 = 0 ;
50429
50430 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50432 if (!SWIG_IsOK(res1)) {
50433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50434 }
50435 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50436 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50437 if (!SWIG_IsOK(res2)) {
50438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50439 }
50440 arg2 = reinterpret_cast< wxSizer * >(argp2);
50441 {
50442 PyThreadState* __tstate = wxPyBeginAllowThreads();
50443 result = (arg1)->GetItemPosition(arg2);
50444 wxPyEndAllowThreads(__tstate);
50445 if (PyErr_Occurred()) SWIG_fail;
50446 }
50447 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50448 return resultobj;
50449 fail:
50450 return NULL;
50451 }
50452
50453
50454 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50455 PyObject *resultobj = 0;
50456 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50457 size_t arg2 ;
50458 wxGBPosition result;
50459 void *argp1 = 0 ;
50460 int res1 = 0 ;
50461 size_t val2 ;
50462 int ecode2 = 0 ;
50463
50464 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50466 if (!SWIG_IsOK(res1)) {
50467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50468 }
50469 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50470 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50471 if (!SWIG_IsOK(ecode2)) {
50472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50473 }
50474 arg2 = static_cast< size_t >(val2);
50475 {
50476 PyThreadState* __tstate = wxPyBeginAllowThreads();
50477 result = (arg1)->GetItemPosition(arg2);
50478 wxPyEndAllowThreads(__tstate);
50479 if (PyErr_Occurred()) SWIG_fail;
50480 }
50481 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50482 return resultobj;
50483 fail:
50484 return NULL;
50485 }
50486
50487
50488 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50489 int argc;
50490 PyObject *argv[3];
50491
50492 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50493 --argc;
50494 if (argc == 2) {
50495 int _v = 0;
50496 {
50497 void *vptr = 0;
50498 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50499 _v = SWIG_CheckState(res);
50500 }
50501 if (!_v) goto check_1;
50502 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50503 }
50504 check_1:
50505
50506 if (argc == 2) {
50507 int _v = 0;
50508 {
50509 void *vptr = 0;
50510 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50511 _v = SWIG_CheckState(res);
50512 }
50513 if (!_v) goto check_2;
50514 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50515 }
50516 check_2:
50517
50518 if (argc == 2) {
50519 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50520 }
50521
50522 fail:
50523 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50524 return NULL;
50525 }
50526
50527
50528 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50529 PyObject *resultobj = 0;
50530 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50531 wxWindow *arg2 = (wxWindow *) 0 ;
50532 wxGBPosition *arg3 = 0 ;
50533 bool result;
50534 void *argp1 = 0 ;
50535 int res1 = 0 ;
50536 void *argp2 = 0 ;
50537 int res2 = 0 ;
50538 wxGBPosition temp3 ;
50539
50540 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50542 if (!SWIG_IsOK(res1)) {
50543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50544 }
50545 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50546 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50547 if (!SWIG_IsOK(res2)) {
50548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50549 }
50550 arg2 = reinterpret_cast< wxWindow * >(argp2);
50551 {
50552 arg3 = &temp3;
50553 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50554 }
50555 {
50556 PyThreadState* __tstate = wxPyBeginAllowThreads();
50557 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50558 wxPyEndAllowThreads(__tstate);
50559 if (PyErr_Occurred()) SWIG_fail;
50560 }
50561 {
50562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50563 }
50564 return resultobj;
50565 fail:
50566 return NULL;
50567 }
50568
50569
50570 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50571 PyObject *resultobj = 0;
50572 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50573 wxSizer *arg2 = (wxSizer *) 0 ;
50574 wxGBPosition *arg3 = 0 ;
50575 bool result;
50576 void *argp1 = 0 ;
50577 int res1 = 0 ;
50578 void *argp2 = 0 ;
50579 int res2 = 0 ;
50580 wxGBPosition temp3 ;
50581
50582 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50584 if (!SWIG_IsOK(res1)) {
50585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50586 }
50587 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50588 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50589 if (!SWIG_IsOK(res2)) {
50590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50591 }
50592 arg2 = reinterpret_cast< wxSizer * >(argp2);
50593 {
50594 arg3 = &temp3;
50595 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50596 }
50597 {
50598 PyThreadState* __tstate = wxPyBeginAllowThreads();
50599 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50600 wxPyEndAllowThreads(__tstate);
50601 if (PyErr_Occurred()) SWIG_fail;
50602 }
50603 {
50604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50605 }
50606 return resultobj;
50607 fail:
50608 return NULL;
50609 }
50610
50611
50612 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50613 PyObject *resultobj = 0;
50614 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50615 size_t arg2 ;
50616 wxGBPosition *arg3 = 0 ;
50617 bool result;
50618 void *argp1 = 0 ;
50619 int res1 = 0 ;
50620 size_t val2 ;
50621 int ecode2 = 0 ;
50622 wxGBPosition temp3 ;
50623
50624 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50626 if (!SWIG_IsOK(res1)) {
50627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50628 }
50629 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50630 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50631 if (!SWIG_IsOK(ecode2)) {
50632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50633 }
50634 arg2 = static_cast< size_t >(val2);
50635 {
50636 arg3 = &temp3;
50637 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50638 }
50639 {
50640 PyThreadState* __tstate = wxPyBeginAllowThreads();
50641 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50642 wxPyEndAllowThreads(__tstate);
50643 if (PyErr_Occurred()) SWIG_fail;
50644 }
50645 {
50646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50647 }
50648 return resultobj;
50649 fail:
50650 return NULL;
50651 }
50652
50653
50654 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50655 int argc;
50656 PyObject *argv[4];
50657
50658 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50659 --argc;
50660 if (argc == 3) {
50661 int _v = 0;
50662 {
50663 void *vptr = 0;
50664 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50665 _v = SWIG_CheckState(res);
50666 }
50667 if (!_v) goto check_1;
50668 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50669 }
50670 check_1:
50671
50672 if (argc == 3) {
50673 int _v = 0;
50674 {
50675 void *vptr = 0;
50676 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50677 _v = SWIG_CheckState(res);
50678 }
50679 if (!_v) goto check_2;
50680 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50681 }
50682 check_2:
50683
50684 if (argc == 3) {
50685 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50686 }
50687
50688 fail:
50689 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50690 return NULL;
50691 }
50692
50693
50694 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50695 PyObject *resultobj = 0;
50696 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50697 wxWindow *arg2 = (wxWindow *) 0 ;
50698 wxGBSpan result;
50699 void *argp1 = 0 ;
50700 int res1 = 0 ;
50701 void *argp2 = 0 ;
50702 int res2 = 0 ;
50703
50704 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50706 if (!SWIG_IsOK(res1)) {
50707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50708 }
50709 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50710 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50711 if (!SWIG_IsOK(res2)) {
50712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50713 }
50714 arg2 = reinterpret_cast< wxWindow * >(argp2);
50715 {
50716 PyThreadState* __tstate = wxPyBeginAllowThreads();
50717 result = (arg1)->GetItemSpan(arg2);
50718 wxPyEndAllowThreads(__tstate);
50719 if (PyErr_Occurred()) SWIG_fail;
50720 }
50721 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50722 return resultobj;
50723 fail:
50724 return NULL;
50725 }
50726
50727
50728 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50729 PyObject *resultobj = 0;
50730 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50731 wxSizer *arg2 = (wxSizer *) 0 ;
50732 wxGBSpan result;
50733 void *argp1 = 0 ;
50734 int res1 = 0 ;
50735 void *argp2 = 0 ;
50736 int res2 = 0 ;
50737
50738 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50740 if (!SWIG_IsOK(res1)) {
50741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50742 }
50743 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50744 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50745 if (!SWIG_IsOK(res2)) {
50746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50747 }
50748 arg2 = reinterpret_cast< wxSizer * >(argp2);
50749 {
50750 PyThreadState* __tstate = wxPyBeginAllowThreads();
50751 result = (arg1)->GetItemSpan(arg2);
50752 wxPyEndAllowThreads(__tstate);
50753 if (PyErr_Occurred()) SWIG_fail;
50754 }
50755 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50756 return resultobj;
50757 fail:
50758 return NULL;
50759 }
50760
50761
50762 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50763 PyObject *resultobj = 0;
50764 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50765 size_t arg2 ;
50766 wxGBSpan result;
50767 void *argp1 = 0 ;
50768 int res1 = 0 ;
50769 size_t val2 ;
50770 int ecode2 = 0 ;
50771
50772 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50774 if (!SWIG_IsOK(res1)) {
50775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50776 }
50777 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50778 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50779 if (!SWIG_IsOK(ecode2)) {
50780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50781 }
50782 arg2 = static_cast< size_t >(val2);
50783 {
50784 PyThreadState* __tstate = wxPyBeginAllowThreads();
50785 result = (arg1)->GetItemSpan(arg2);
50786 wxPyEndAllowThreads(__tstate);
50787 if (PyErr_Occurred()) SWIG_fail;
50788 }
50789 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50790 return resultobj;
50791 fail:
50792 return NULL;
50793 }
50794
50795
50796 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50797 int argc;
50798 PyObject *argv[3];
50799
50800 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50801 --argc;
50802 if (argc == 2) {
50803 int _v = 0;
50804 {
50805 void *vptr = 0;
50806 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50807 _v = SWIG_CheckState(res);
50808 }
50809 if (!_v) goto check_1;
50810 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50811 }
50812 check_1:
50813
50814 if (argc == 2) {
50815 int _v = 0;
50816 {
50817 void *vptr = 0;
50818 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50819 _v = SWIG_CheckState(res);
50820 }
50821 if (!_v) goto check_2;
50822 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50823 }
50824 check_2:
50825
50826 if (argc == 2) {
50827 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50828 }
50829
50830 fail:
50831 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50832 return NULL;
50833 }
50834
50835
50836 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50837 PyObject *resultobj = 0;
50838 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50839 wxWindow *arg2 = (wxWindow *) 0 ;
50840 wxGBSpan *arg3 = 0 ;
50841 bool result;
50842 void *argp1 = 0 ;
50843 int res1 = 0 ;
50844 void *argp2 = 0 ;
50845 int res2 = 0 ;
50846 wxGBSpan temp3 ;
50847
50848 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50850 if (!SWIG_IsOK(res1)) {
50851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50852 }
50853 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50854 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50855 if (!SWIG_IsOK(res2)) {
50856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50857 }
50858 arg2 = reinterpret_cast< wxWindow * >(argp2);
50859 {
50860 arg3 = &temp3;
50861 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50862 }
50863 {
50864 PyThreadState* __tstate = wxPyBeginAllowThreads();
50865 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50866 wxPyEndAllowThreads(__tstate);
50867 if (PyErr_Occurred()) SWIG_fail;
50868 }
50869 {
50870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50871 }
50872 return resultobj;
50873 fail:
50874 return NULL;
50875 }
50876
50877
50878 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50879 PyObject *resultobj = 0;
50880 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50881 wxSizer *arg2 = (wxSizer *) 0 ;
50882 wxGBSpan *arg3 = 0 ;
50883 bool result;
50884 void *argp1 = 0 ;
50885 int res1 = 0 ;
50886 void *argp2 = 0 ;
50887 int res2 = 0 ;
50888 wxGBSpan temp3 ;
50889
50890 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50892 if (!SWIG_IsOK(res1)) {
50893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50894 }
50895 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50896 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50897 if (!SWIG_IsOK(res2)) {
50898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50899 }
50900 arg2 = reinterpret_cast< wxSizer * >(argp2);
50901 {
50902 arg3 = &temp3;
50903 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50904 }
50905 {
50906 PyThreadState* __tstate = wxPyBeginAllowThreads();
50907 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50908 wxPyEndAllowThreads(__tstate);
50909 if (PyErr_Occurred()) SWIG_fail;
50910 }
50911 {
50912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50913 }
50914 return resultobj;
50915 fail:
50916 return NULL;
50917 }
50918
50919
50920 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50921 PyObject *resultobj = 0;
50922 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50923 size_t arg2 ;
50924 wxGBSpan *arg3 = 0 ;
50925 bool result;
50926 void *argp1 = 0 ;
50927 int res1 = 0 ;
50928 size_t val2 ;
50929 int ecode2 = 0 ;
50930 wxGBSpan temp3 ;
50931
50932 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50934 if (!SWIG_IsOK(res1)) {
50935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50936 }
50937 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50938 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50939 if (!SWIG_IsOK(ecode2)) {
50940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50941 }
50942 arg2 = static_cast< size_t >(val2);
50943 {
50944 arg3 = &temp3;
50945 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50946 }
50947 {
50948 PyThreadState* __tstate = wxPyBeginAllowThreads();
50949 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50950 wxPyEndAllowThreads(__tstate);
50951 if (PyErr_Occurred()) SWIG_fail;
50952 }
50953 {
50954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50955 }
50956 return resultobj;
50957 fail:
50958 return NULL;
50959 }
50960
50961
50962 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50963 int argc;
50964 PyObject *argv[4];
50965
50966 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50967 --argc;
50968 if (argc == 3) {
50969 int _v = 0;
50970 {
50971 void *vptr = 0;
50972 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50973 _v = SWIG_CheckState(res);
50974 }
50975 if (!_v) goto check_1;
50976 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50977 }
50978 check_1:
50979
50980 if (argc == 3) {
50981 int _v = 0;
50982 {
50983 void *vptr = 0;
50984 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50985 _v = SWIG_CheckState(res);
50986 }
50987 if (!_v) goto check_2;
50988 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50989 }
50990 check_2:
50991
50992 if (argc == 3) {
50993 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50994 }
50995
50996 fail:
50997 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50998 return NULL;
50999 }
51000
51001
51002 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51003 PyObject *resultobj = 0;
51004 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51005 wxWindow *arg2 = (wxWindow *) 0 ;
51006 wxGBSizerItem *result = 0 ;
51007 void *argp1 = 0 ;
51008 int res1 = 0 ;
51009 void *argp2 = 0 ;
51010 int res2 = 0 ;
51011
51012 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51014 if (!SWIG_IsOK(res1)) {
51015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51016 }
51017 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51018 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51019 if (!SWIG_IsOK(res2)) {
51020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51021 }
51022 arg2 = reinterpret_cast< wxWindow * >(argp2);
51023 {
51024 PyThreadState* __tstate = wxPyBeginAllowThreads();
51025 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51026 wxPyEndAllowThreads(__tstate);
51027 if (PyErr_Occurred()) SWIG_fail;
51028 }
51029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51030 return resultobj;
51031 fail:
51032 return NULL;
51033 }
51034
51035
51036 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51037 PyObject *resultobj = 0;
51038 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51039 wxSizer *arg2 = (wxSizer *) 0 ;
51040 wxGBSizerItem *result = 0 ;
51041 void *argp1 = 0 ;
51042 int res1 = 0 ;
51043 void *argp2 = 0 ;
51044 int res2 = 0 ;
51045
51046 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51048 if (!SWIG_IsOK(res1)) {
51049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51050 }
51051 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51052 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51053 if (!SWIG_IsOK(res2)) {
51054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51055 }
51056 arg2 = reinterpret_cast< wxSizer * >(argp2);
51057 {
51058 PyThreadState* __tstate = wxPyBeginAllowThreads();
51059 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51060 wxPyEndAllowThreads(__tstate);
51061 if (PyErr_Occurred()) SWIG_fail;
51062 }
51063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51064 return resultobj;
51065 fail:
51066 return NULL;
51067 }
51068
51069
51070 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51071 int argc;
51072 PyObject *argv[3];
51073
51074 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51075 --argc;
51076 if (argc == 2) {
51077 int _v = 0;
51078 {
51079 void *vptr = 0;
51080 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51081 _v = SWIG_CheckState(res);
51082 }
51083 if (!_v) goto check_1;
51084 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51085 }
51086 check_1:
51087
51088 if (argc == 2) {
51089 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51090 }
51091
51092 fail:
51093 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51094 return NULL;
51095 }
51096
51097
51098 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51099 PyObject *resultobj = 0;
51100 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51101 wxGBPosition *arg2 = 0 ;
51102 wxGBSizerItem *result = 0 ;
51103 void *argp1 = 0 ;
51104 int res1 = 0 ;
51105 wxGBPosition temp2 ;
51106 PyObject * obj0 = 0 ;
51107 PyObject * obj1 = 0 ;
51108 char * kwnames[] = {
51109 (char *) "self",(char *) "pos", NULL
51110 };
51111
51112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51114 if (!SWIG_IsOK(res1)) {
51115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51116 }
51117 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51118 {
51119 arg2 = &temp2;
51120 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51121 }
51122 {
51123 PyThreadState* __tstate = wxPyBeginAllowThreads();
51124 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51125 wxPyEndAllowThreads(__tstate);
51126 if (PyErr_Occurred()) SWIG_fail;
51127 }
51128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51129 return resultobj;
51130 fail:
51131 return NULL;
51132 }
51133
51134
51135 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51136 PyObject *resultobj = 0;
51137 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51138 wxPoint *arg2 = 0 ;
51139 wxGBSizerItem *result = 0 ;
51140 void *argp1 = 0 ;
51141 int res1 = 0 ;
51142 wxPoint temp2 ;
51143 PyObject * obj0 = 0 ;
51144 PyObject * obj1 = 0 ;
51145 char * kwnames[] = {
51146 (char *) "self",(char *) "pt", NULL
51147 };
51148
51149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51151 if (!SWIG_IsOK(res1)) {
51152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51153 }
51154 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51155 {
51156 arg2 = &temp2;
51157 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51158 }
51159 {
51160 PyThreadState* __tstate = wxPyBeginAllowThreads();
51161 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51162 wxPyEndAllowThreads(__tstate);
51163 if (PyErr_Occurred()) SWIG_fail;
51164 }
51165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51166 return resultobj;
51167 fail:
51168 return NULL;
51169 }
51170
51171
51172 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51173 PyObject *resultobj = 0;
51174 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51175 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51176 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51177 bool result;
51178 void *argp1 = 0 ;
51179 int res1 = 0 ;
51180 void *argp2 = 0 ;
51181 int res2 = 0 ;
51182 void *argp3 = 0 ;
51183 int res3 = 0 ;
51184 PyObject * obj0 = 0 ;
51185 PyObject * obj1 = 0 ;
51186 PyObject * obj2 = 0 ;
51187 char * kwnames[] = {
51188 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51189 };
51190
51191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51193 if (!SWIG_IsOK(res1)) {
51194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51195 }
51196 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51197 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51198 if (!SWIG_IsOK(res2)) {
51199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51200 }
51201 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51202 if (obj2) {
51203 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51204 if (!SWIG_IsOK(res3)) {
51205 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51206 }
51207 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51208 }
51209 {
51210 PyThreadState* __tstate = wxPyBeginAllowThreads();
51211 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51212 wxPyEndAllowThreads(__tstate);
51213 if (PyErr_Occurred()) SWIG_fail;
51214 }
51215 {
51216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51217 }
51218 return resultobj;
51219 fail:
51220 return NULL;
51221 }
51222
51223
51224 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51225 PyObject *resultobj = 0;
51226 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51227 wxGBPosition *arg2 = 0 ;
51228 wxGBSpan *arg3 = 0 ;
51229 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51230 bool result;
51231 void *argp1 = 0 ;
51232 int res1 = 0 ;
51233 wxGBPosition temp2 ;
51234 wxGBSpan temp3 ;
51235 void *argp4 = 0 ;
51236 int res4 = 0 ;
51237 PyObject * obj0 = 0 ;
51238 PyObject * obj1 = 0 ;
51239 PyObject * obj2 = 0 ;
51240 PyObject * obj3 = 0 ;
51241 char * kwnames[] = {
51242 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51243 };
51244
51245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51247 if (!SWIG_IsOK(res1)) {
51248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51249 }
51250 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51251 {
51252 arg2 = &temp2;
51253 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51254 }
51255 {
51256 arg3 = &temp3;
51257 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51258 }
51259 if (obj3) {
51260 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51261 if (!SWIG_IsOK(res4)) {
51262 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51263 }
51264 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51265 }
51266 {
51267 PyThreadState* __tstate = wxPyBeginAllowThreads();
51268 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51269 wxPyEndAllowThreads(__tstate);
51270 if (PyErr_Occurred()) SWIG_fail;
51271 }
51272 {
51273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51274 }
51275 return resultobj;
51276 fail:
51277 return NULL;
51278 }
51279
51280
51281 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51282 PyObject *obj;
51283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51284 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51285 return SWIG_Py_Void();
51286 }
51287
51288 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51289 return SWIG_Python_InitShadowInstance(args);
51290 }
51291
51292 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51293 PyObject *resultobj = 0;
51294 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51295 wxRelationship arg2 ;
51296 wxWindow *arg3 = (wxWindow *) 0 ;
51297 wxEdge arg4 ;
51298 int arg5 = (int) 0 ;
51299 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51300 void *argp1 = 0 ;
51301 int res1 = 0 ;
51302 int val2 ;
51303 int ecode2 = 0 ;
51304 void *argp3 = 0 ;
51305 int res3 = 0 ;
51306 int val4 ;
51307 int ecode4 = 0 ;
51308 int val5 ;
51309 int ecode5 = 0 ;
51310 int val6 ;
51311 int ecode6 = 0 ;
51312 PyObject * obj0 = 0 ;
51313 PyObject * obj1 = 0 ;
51314 PyObject * obj2 = 0 ;
51315 PyObject * obj3 = 0 ;
51316 PyObject * obj4 = 0 ;
51317 PyObject * obj5 = 0 ;
51318 char * kwnames[] = {
51319 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51320 };
51321
51322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51324 if (!SWIG_IsOK(res1)) {
51325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51326 }
51327 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51328 ecode2 = SWIG_AsVal_int(obj1, &val2);
51329 if (!SWIG_IsOK(ecode2)) {
51330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51331 }
51332 arg2 = static_cast< wxRelationship >(val2);
51333 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51334 if (!SWIG_IsOK(res3)) {
51335 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51336 }
51337 arg3 = reinterpret_cast< wxWindow * >(argp3);
51338 ecode4 = SWIG_AsVal_int(obj3, &val4);
51339 if (!SWIG_IsOK(ecode4)) {
51340 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51341 }
51342 arg4 = static_cast< wxEdge >(val4);
51343 if (obj4) {
51344 ecode5 = SWIG_AsVal_int(obj4, &val5);
51345 if (!SWIG_IsOK(ecode5)) {
51346 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51347 }
51348 arg5 = static_cast< int >(val5);
51349 }
51350 if (obj5) {
51351 ecode6 = SWIG_AsVal_int(obj5, &val6);
51352 if (!SWIG_IsOK(ecode6)) {
51353 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51354 }
51355 arg6 = static_cast< int >(val6);
51356 }
51357 {
51358 PyThreadState* __tstate = wxPyBeginAllowThreads();
51359 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51360 wxPyEndAllowThreads(__tstate);
51361 if (PyErr_Occurred()) SWIG_fail;
51362 }
51363 resultobj = SWIG_Py_Void();
51364 return resultobj;
51365 fail:
51366 return NULL;
51367 }
51368
51369
51370 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51371 PyObject *resultobj = 0;
51372 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51373 wxWindow *arg2 = (wxWindow *) 0 ;
51374 int arg3 = (int) 0 ;
51375 void *argp1 = 0 ;
51376 int res1 = 0 ;
51377 void *argp2 = 0 ;
51378 int res2 = 0 ;
51379 int val3 ;
51380 int ecode3 = 0 ;
51381 PyObject * obj0 = 0 ;
51382 PyObject * obj1 = 0 ;
51383 PyObject * obj2 = 0 ;
51384 char * kwnames[] = {
51385 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51386 };
51387
51388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51390 if (!SWIG_IsOK(res1)) {
51391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51392 }
51393 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51395 if (!SWIG_IsOK(res2)) {
51396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51397 }
51398 arg2 = reinterpret_cast< wxWindow * >(argp2);
51399 if (obj2) {
51400 ecode3 = SWIG_AsVal_int(obj2, &val3);
51401 if (!SWIG_IsOK(ecode3)) {
51402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51403 }
51404 arg3 = static_cast< int >(val3);
51405 }
51406 {
51407 PyThreadState* __tstate = wxPyBeginAllowThreads();
51408 (arg1)->LeftOf(arg2,arg3);
51409 wxPyEndAllowThreads(__tstate);
51410 if (PyErr_Occurred()) SWIG_fail;
51411 }
51412 resultobj = SWIG_Py_Void();
51413 return resultobj;
51414 fail:
51415 return NULL;
51416 }
51417
51418
51419 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51420 PyObject *resultobj = 0;
51421 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51422 wxWindow *arg2 = (wxWindow *) 0 ;
51423 int arg3 = (int) 0 ;
51424 void *argp1 = 0 ;
51425 int res1 = 0 ;
51426 void *argp2 = 0 ;
51427 int res2 = 0 ;
51428 int val3 ;
51429 int ecode3 = 0 ;
51430 PyObject * obj0 = 0 ;
51431 PyObject * obj1 = 0 ;
51432 PyObject * obj2 = 0 ;
51433 char * kwnames[] = {
51434 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51435 };
51436
51437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51439 if (!SWIG_IsOK(res1)) {
51440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51441 }
51442 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51443 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51444 if (!SWIG_IsOK(res2)) {
51445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51446 }
51447 arg2 = reinterpret_cast< wxWindow * >(argp2);
51448 if (obj2) {
51449 ecode3 = SWIG_AsVal_int(obj2, &val3);
51450 if (!SWIG_IsOK(ecode3)) {
51451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51452 }
51453 arg3 = static_cast< int >(val3);
51454 }
51455 {
51456 PyThreadState* __tstate = wxPyBeginAllowThreads();
51457 (arg1)->RightOf(arg2,arg3);
51458 wxPyEndAllowThreads(__tstate);
51459 if (PyErr_Occurred()) SWIG_fail;
51460 }
51461 resultobj = SWIG_Py_Void();
51462 return resultobj;
51463 fail:
51464 return NULL;
51465 }
51466
51467
51468 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51469 PyObject *resultobj = 0;
51470 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51471 wxWindow *arg2 = (wxWindow *) 0 ;
51472 int arg3 = (int) 0 ;
51473 void *argp1 = 0 ;
51474 int res1 = 0 ;
51475 void *argp2 = 0 ;
51476 int res2 = 0 ;
51477 int val3 ;
51478 int ecode3 = 0 ;
51479 PyObject * obj0 = 0 ;
51480 PyObject * obj1 = 0 ;
51481 PyObject * obj2 = 0 ;
51482 char * kwnames[] = {
51483 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51484 };
51485
51486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51488 if (!SWIG_IsOK(res1)) {
51489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51490 }
51491 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51493 if (!SWIG_IsOK(res2)) {
51494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51495 }
51496 arg2 = reinterpret_cast< wxWindow * >(argp2);
51497 if (obj2) {
51498 ecode3 = SWIG_AsVal_int(obj2, &val3);
51499 if (!SWIG_IsOK(ecode3)) {
51500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51501 }
51502 arg3 = static_cast< int >(val3);
51503 }
51504 {
51505 PyThreadState* __tstate = wxPyBeginAllowThreads();
51506 (arg1)->Above(arg2,arg3);
51507 wxPyEndAllowThreads(__tstate);
51508 if (PyErr_Occurred()) SWIG_fail;
51509 }
51510 resultobj = SWIG_Py_Void();
51511 return resultobj;
51512 fail:
51513 return NULL;
51514 }
51515
51516
51517 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51518 PyObject *resultobj = 0;
51519 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51520 wxWindow *arg2 = (wxWindow *) 0 ;
51521 int arg3 = (int) 0 ;
51522 void *argp1 = 0 ;
51523 int res1 = 0 ;
51524 void *argp2 = 0 ;
51525 int res2 = 0 ;
51526 int val3 ;
51527 int ecode3 = 0 ;
51528 PyObject * obj0 = 0 ;
51529 PyObject * obj1 = 0 ;
51530 PyObject * obj2 = 0 ;
51531 char * kwnames[] = {
51532 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51533 };
51534
51535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51537 if (!SWIG_IsOK(res1)) {
51538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51539 }
51540 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51541 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51542 if (!SWIG_IsOK(res2)) {
51543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51544 }
51545 arg2 = reinterpret_cast< wxWindow * >(argp2);
51546 if (obj2) {
51547 ecode3 = SWIG_AsVal_int(obj2, &val3);
51548 if (!SWIG_IsOK(ecode3)) {
51549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51550 }
51551 arg3 = static_cast< int >(val3);
51552 }
51553 {
51554 PyThreadState* __tstate = wxPyBeginAllowThreads();
51555 (arg1)->Below(arg2,arg3);
51556 wxPyEndAllowThreads(__tstate);
51557 if (PyErr_Occurred()) SWIG_fail;
51558 }
51559 resultobj = SWIG_Py_Void();
51560 return resultobj;
51561 fail:
51562 return NULL;
51563 }
51564
51565
51566 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51567 PyObject *resultobj = 0;
51568 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51569 wxWindow *arg2 = (wxWindow *) 0 ;
51570 wxEdge arg3 ;
51571 int arg4 = (int) 0 ;
51572 void *argp1 = 0 ;
51573 int res1 = 0 ;
51574 void *argp2 = 0 ;
51575 int res2 = 0 ;
51576 int val3 ;
51577 int ecode3 = 0 ;
51578 int val4 ;
51579 int ecode4 = 0 ;
51580 PyObject * obj0 = 0 ;
51581 PyObject * obj1 = 0 ;
51582 PyObject * obj2 = 0 ;
51583 PyObject * obj3 = 0 ;
51584 char * kwnames[] = {
51585 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51586 };
51587
51588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51590 if (!SWIG_IsOK(res1)) {
51591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51592 }
51593 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51595 if (!SWIG_IsOK(res2)) {
51596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51597 }
51598 arg2 = reinterpret_cast< wxWindow * >(argp2);
51599 ecode3 = SWIG_AsVal_int(obj2, &val3);
51600 if (!SWIG_IsOK(ecode3)) {
51601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51602 }
51603 arg3 = static_cast< wxEdge >(val3);
51604 if (obj3) {
51605 ecode4 = SWIG_AsVal_int(obj3, &val4);
51606 if (!SWIG_IsOK(ecode4)) {
51607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51608 }
51609 arg4 = static_cast< int >(val4);
51610 }
51611 {
51612 PyThreadState* __tstate = wxPyBeginAllowThreads();
51613 (arg1)->SameAs(arg2,arg3,arg4);
51614 wxPyEndAllowThreads(__tstate);
51615 if (PyErr_Occurred()) SWIG_fail;
51616 }
51617 resultobj = SWIG_Py_Void();
51618 return resultobj;
51619 fail:
51620 return NULL;
51621 }
51622
51623
51624 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51625 PyObject *resultobj = 0;
51626 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51627 wxWindow *arg2 = (wxWindow *) 0 ;
51628 wxEdge arg3 ;
51629 int arg4 ;
51630 void *argp1 = 0 ;
51631 int res1 = 0 ;
51632 void *argp2 = 0 ;
51633 int res2 = 0 ;
51634 int val3 ;
51635 int ecode3 = 0 ;
51636 int val4 ;
51637 int ecode4 = 0 ;
51638 PyObject * obj0 = 0 ;
51639 PyObject * obj1 = 0 ;
51640 PyObject * obj2 = 0 ;
51641 PyObject * obj3 = 0 ;
51642 char * kwnames[] = {
51643 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51644 };
51645
51646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51648 if (!SWIG_IsOK(res1)) {
51649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51650 }
51651 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51653 if (!SWIG_IsOK(res2)) {
51654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51655 }
51656 arg2 = reinterpret_cast< wxWindow * >(argp2);
51657 ecode3 = SWIG_AsVal_int(obj2, &val3);
51658 if (!SWIG_IsOK(ecode3)) {
51659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51660 }
51661 arg3 = static_cast< wxEdge >(val3);
51662 ecode4 = SWIG_AsVal_int(obj3, &val4);
51663 if (!SWIG_IsOK(ecode4)) {
51664 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51665 }
51666 arg4 = static_cast< int >(val4);
51667 {
51668 PyThreadState* __tstate = wxPyBeginAllowThreads();
51669 (arg1)->PercentOf(arg2,arg3,arg4);
51670 wxPyEndAllowThreads(__tstate);
51671 if (PyErr_Occurred()) SWIG_fail;
51672 }
51673 resultobj = SWIG_Py_Void();
51674 return resultobj;
51675 fail:
51676 return NULL;
51677 }
51678
51679
51680 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51681 PyObject *resultobj = 0;
51682 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51683 int arg2 ;
51684 void *argp1 = 0 ;
51685 int res1 = 0 ;
51686 int val2 ;
51687 int ecode2 = 0 ;
51688 PyObject * obj0 = 0 ;
51689 PyObject * obj1 = 0 ;
51690 char * kwnames[] = {
51691 (char *) "self",(char *) "val", NULL
51692 };
51693
51694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51696 if (!SWIG_IsOK(res1)) {
51697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51698 }
51699 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51700 ecode2 = SWIG_AsVal_int(obj1, &val2);
51701 if (!SWIG_IsOK(ecode2)) {
51702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51703 }
51704 arg2 = static_cast< int >(val2);
51705 {
51706 PyThreadState* __tstate = wxPyBeginAllowThreads();
51707 (arg1)->Absolute(arg2);
51708 wxPyEndAllowThreads(__tstate);
51709 if (PyErr_Occurred()) SWIG_fail;
51710 }
51711 resultobj = SWIG_Py_Void();
51712 return resultobj;
51713 fail:
51714 return NULL;
51715 }
51716
51717
51718 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51719 PyObject *resultobj = 0;
51720 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51721 void *argp1 = 0 ;
51722 int res1 = 0 ;
51723 PyObject *swig_obj[1] ;
51724
51725 if (!args) SWIG_fail;
51726 swig_obj[0] = args;
51727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51728 if (!SWIG_IsOK(res1)) {
51729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51730 }
51731 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51732 {
51733 PyThreadState* __tstate = wxPyBeginAllowThreads();
51734 (arg1)->Unconstrained();
51735 wxPyEndAllowThreads(__tstate);
51736 if (PyErr_Occurred()) SWIG_fail;
51737 }
51738 resultobj = SWIG_Py_Void();
51739 return resultobj;
51740 fail:
51741 return NULL;
51742 }
51743
51744
51745 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51746 PyObject *resultobj = 0;
51747 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51748 void *argp1 = 0 ;
51749 int res1 = 0 ;
51750 PyObject *swig_obj[1] ;
51751
51752 if (!args) SWIG_fail;
51753 swig_obj[0] = args;
51754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51755 if (!SWIG_IsOK(res1)) {
51756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51757 }
51758 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51759 {
51760 PyThreadState* __tstate = wxPyBeginAllowThreads();
51761 (arg1)->AsIs();
51762 wxPyEndAllowThreads(__tstate);
51763 if (PyErr_Occurred()) SWIG_fail;
51764 }
51765 resultobj = SWIG_Py_Void();
51766 return resultobj;
51767 fail:
51768 return NULL;
51769 }
51770
51771
51772 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51773 PyObject *resultobj = 0;
51774 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51775 wxWindow *result = 0 ;
51776 void *argp1 = 0 ;
51777 int res1 = 0 ;
51778 PyObject *swig_obj[1] ;
51779
51780 if (!args) SWIG_fail;
51781 swig_obj[0] = args;
51782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51783 if (!SWIG_IsOK(res1)) {
51784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51785 }
51786 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51787 {
51788 PyThreadState* __tstate = wxPyBeginAllowThreads();
51789 result = (wxWindow *)(arg1)->GetOtherWindow();
51790 wxPyEndAllowThreads(__tstate);
51791 if (PyErr_Occurred()) SWIG_fail;
51792 }
51793 {
51794 resultobj = wxPyMake_wxObject(result, 0);
51795 }
51796 return resultobj;
51797 fail:
51798 return NULL;
51799 }
51800
51801
51802 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51803 PyObject *resultobj = 0;
51804 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51805 wxEdge result;
51806 void *argp1 = 0 ;
51807 int res1 = 0 ;
51808 PyObject *swig_obj[1] ;
51809
51810 if (!args) SWIG_fail;
51811 swig_obj[0] = args;
51812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51813 if (!SWIG_IsOK(res1)) {
51814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51815 }
51816 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51817 {
51818 PyThreadState* __tstate = wxPyBeginAllowThreads();
51819 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51820 wxPyEndAllowThreads(__tstate);
51821 if (PyErr_Occurred()) SWIG_fail;
51822 }
51823 resultobj = SWIG_From_int(static_cast< int >(result));
51824 return resultobj;
51825 fail:
51826 return NULL;
51827 }
51828
51829
51830 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51831 PyObject *resultobj = 0;
51832 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51833 wxEdge arg2 ;
51834 void *argp1 = 0 ;
51835 int res1 = 0 ;
51836 int val2 ;
51837 int ecode2 = 0 ;
51838 PyObject * obj0 = 0 ;
51839 PyObject * obj1 = 0 ;
51840 char * kwnames[] = {
51841 (char *) "self",(char *) "which", NULL
51842 };
51843
51844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51846 if (!SWIG_IsOK(res1)) {
51847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51848 }
51849 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51850 ecode2 = SWIG_AsVal_int(obj1, &val2);
51851 if (!SWIG_IsOK(ecode2)) {
51852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51853 }
51854 arg2 = static_cast< wxEdge >(val2);
51855 {
51856 PyThreadState* __tstate = wxPyBeginAllowThreads();
51857 (arg1)->SetEdge(arg2);
51858 wxPyEndAllowThreads(__tstate);
51859 if (PyErr_Occurred()) SWIG_fail;
51860 }
51861 resultobj = SWIG_Py_Void();
51862 return resultobj;
51863 fail:
51864 return NULL;
51865 }
51866
51867
51868 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51869 PyObject *resultobj = 0;
51870 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51871 int arg2 ;
51872 void *argp1 = 0 ;
51873 int res1 = 0 ;
51874 int val2 ;
51875 int ecode2 = 0 ;
51876 PyObject * obj0 = 0 ;
51877 PyObject * obj1 = 0 ;
51878 char * kwnames[] = {
51879 (char *) "self",(char *) "v", NULL
51880 };
51881
51882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51884 if (!SWIG_IsOK(res1)) {
51885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51886 }
51887 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51888 ecode2 = SWIG_AsVal_int(obj1, &val2);
51889 if (!SWIG_IsOK(ecode2)) {
51890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51891 }
51892 arg2 = static_cast< int >(val2);
51893 {
51894 PyThreadState* __tstate = wxPyBeginAllowThreads();
51895 (arg1)->SetValue(arg2);
51896 wxPyEndAllowThreads(__tstate);
51897 if (PyErr_Occurred()) SWIG_fail;
51898 }
51899 resultobj = SWIG_Py_Void();
51900 return resultobj;
51901 fail:
51902 return NULL;
51903 }
51904
51905
51906 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51907 PyObject *resultobj = 0;
51908 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51909 int result;
51910 void *argp1 = 0 ;
51911 int res1 = 0 ;
51912 PyObject *swig_obj[1] ;
51913
51914 if (!args) SWIG_fail;
51915 swig_obj[0] = args;
51916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51917 if (!SWIG_IsOK(res1)) {
51918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51919 }
51920 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51921 {
51922 PyThreadState* __tstate = wxPyBeginAllowThreads();
51923 result = (int)(arg1)->GetMargin();
51924 wxPyEndAllowThreads(__tstate);
51925 if (PyErr_Occurred()) SWIG_fail;
51926 }
51927 resultobj = SWIG_From_int(static_cast< int >(result));
51928 return resultobj;
51929 fail:
51930 return NULL;
51931 }
51932
51933
51934 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51935 PyObject *resultobj = 0;
51936 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51937 int arg2 ;
51938 void *argp1 = 0 ;
51939 int res1 = 0 ;
51940 int val2 ;
51941 int ecode2 = 0 ;
51942 PyObject * obj0 = 0 ;
51943 PyObject * obj1 = 0 ;
51944 char * kwnames[] = {
51945 (char *) "self",(char *) "m", NULL
51946 };
51947
51948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51950 if (!SWIG_IsOK(res1)) {
51951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51952 }
51953 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51954 ecode2 = SWIG_AsVal_int(obj1, &val2);
51955 if (!SWIG_IsOK(ecode2)) {
51956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51957 }
51958 arg2 = static_cast< int >(val2);
51959 {
51960 PyThreadState* __tstate = wxPyBeginAllowThreads();
51961 (arg1)->SetMargin(arg2);
51962 wxPyEndAllowThreads(__tstate);
51963 if (PyErr_Occurred()) SWIG_fail;
51964 }
51965 resultobj = SWIG_Py_Void();
51966 return resultobj;
51967 fail:
51968 return NULL;
51969 }
51970
51971
51972 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51973 PyObject *resultobj = 0;
51974 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51975 int result;
51976 void *argp1 = 0 ;
51977 int res1 = 0 ;
51978 PyObject *swig_obj[1] ;
51979
51980 if (!args) SWIG_fail;
51981 swig_obj[0] = args;
51982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51983 if (!SWIG_IsOK(res1)) {
51984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51985 }
51986 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51987 {
51988 PyThreadState* __tstate = wxPyBeginAllowThreads();
51989 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51990 wxPyEndAllowThreads(__tstate);
51991 if (PyErr_Occurred()) SWIG_fail;
51992 }
51993 resultobj = SWIG_From_int(static_cast< int >(result));
51994 return resultobj;
51995 fail:
51996 return NULL;
51997 }
51998
51999
52000 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52001 PyObject *resultobj = 0;
52002 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52003 int result;
52004 void *argp1 = 0 ;
52005 int res1 = 0 ;
52006 PyObject *swig_obj[1] ;
52007
52008 if (!args) SWIG_fail;
52009 swig_obj[0] = args;
52010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52011 if (!SWIG_IsOK(res1)) {
52012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52013 }
52014 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52015 {
52016 PyThreadState* __tstate = wxPyBeginAllowThreads();
52017 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52018 wxPyEndAllowThreads(__tstate);
52019 if (PyErr_Occurred()) SWIG_fail;
52020 }
52021 resultobj = SWIG_From_int(static_cast< int >(result));
52022 return resultobj;
52023 fail:
52024 return NULL;
52025 }
52026
52027
52028 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52029 PyObject *resultobj = 0;
52030 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52031 int result;
52032 void *argp1 = 0 ;
52033 int res1 = 0 ;
52034 PyObject *swig_obj[1] ;
52035
52036 if (!args) SWIG_fail;
52037 swig_obj[0] = args;
52038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52039 if (!SWIG_IsOK(res1)) {
52040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52041 }
52042 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52043 {
52044 PyThreadState* __tstate = wxPyBeginAllowThreads();
52045 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52046 wxPyEndAllowThreads(__tstate);
52047 if (PyErr_Occurred()) SWIG_fail;
52048 }
52049 resultobj = SWIG_From_int(static_cast< int >(result));
52050 return resultobj;
52051 fail:
52052 return NULL;
52053 }
52054
52055
52056 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52057 PyObject *resultobj = 0;
52058 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52059 bool result;
52060 void *argp1 = 0 ;
52061 int res1 = 0 ;
52062 PyObject *swig_obj[1] ;
52063
52064 if (!args) SWIG_fail;
52065 swig_obj[0] = args;
52066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52067 if (!SWIG_IsOK(res1)) {
52068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52069 }
52070 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52071 {
52072 PyThreadState* __tstate = wxPyBeginAllowThreads();
52073 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52074 wxPyEndAllowThreads(__tstate);
52075 if (PyErr_Occurred()) SWIG_fail;
52076 }
52077 {
52078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52079 }
52080 return resultobj;
52081 fail:
52082 return NULL;
52083 }
52084
52085
52086 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52087 PyObject *resultobj = 0;
52088 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52089 bool arg2 ;
52090 void *argp1 = 0 ;
52091 int res1 = 0 ;
52092 bool val2 ;
52093 int ecode2 = 0 ;
52094 PyObject * obj0 = 0 ;
52095 PyObject * obj1 = 0 ;
52096 char * kwnames[] = {
52097 (char *) "self",(char *) "d", NULL
52098 };
52099
52100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52102 if (!SWIG_IsOK(res1)) {
52103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52104 }
52105 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52106 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52107 if (!SWIG_IsOK(ecode2)) {
52108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52109 }
52110 arg2 = static_cast< bool >(val2);
52111 {
52112 PyThreadState* __tstate = wxPyBeginAllowThreads();
52113 (arg1)->SetDone(arg2);
52114 wxPyEndAllowThreads(__tstate);
52115 if (PyErr_Occurred()) SWIG_fail;
52116 }
52117 resultobj = SWIG_Py_Void();
52118 return resultobj;
52119 fail:
52120 return NULL;
52121 }
52122
52123
52124 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52125 PyObject *resultobj = 0;
52126 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52127 wxRelationship result;
52128 void *argp1 = 0 ;
52129 int res1 = 0 ;
52130 PyObject *swig_obj[1] ;
52131
52132 if (!args) SWIG_fail;
52133 swig_obj[0] = args;
52134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52135 if (!SWIG_IsOK(res1)) {
52136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52137 }
52138 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52139 {
52140 PyThreadState* __tstate = wxPyBeginAllowThreads();
52141 result = (wxRelationship)(arg1)->GetRelationship();
52142 wxPyEndAllowThreads(__tstate);
52143 if (PyErr_Occurred()) SWIG_fail;
52144 }
52145 resultobj = SWIG_From_int(static_cast< int >(result));
52146 return resultobj;
52147 fail:
52148 return NULL;
52149 }
52150
52151
52152 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52153 PyObject *resultobj = 0;
52154 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52155 wxRelationship arg2 ;
52156 void *argp1 = 0 ;
52157 int res1 = 0 ;
52158 int val2 ;
52159 int ecode2 = 0 ;
52160 PyObject * obj0 = 0 ;
52161 PyObject * obj1 = 0 ;
52162 char * kwnames[] = {
52163 (char *) "self",(char *) "r", NULL
52164 };
52165
52166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52168 if (!SWIG_IsOK(res1)) {
52169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52170 }
52171 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52172 ecode2 = SWIG_AsVal_int(obj1, &val2);
52173 if (!SWIG_IsOK(ecode2)) {
52174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52175 }
52176 arg2 = static_cast< wxRelationship >(val2);
52177 {
52178 PyThreadState* __tstate = wxPyBeginAllowThreads();
52179 (arg1)->SetRelationship(arg2);
52180 wxPyEndAllowThreads(__tstate);
52181 if (PyErr_Occurred()) SWIG_fail;
52182 }
52183 resultobj = SWIG_Py_Void();
52184 return resultobj;
52185 fail:
52186 return NULL;
52187 }
52188
52189
52190 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52191 PyObject *resultobj = 0;
52192 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52193 wxWindow *arg2 = (wxWindow *) 0 ;
52194 bool result;
52195 void *argp1 = 0 ;
52196 int res1 = 0 ;
52197 void *argp2 = 0 ;
52198 int res2 = 0 ;
52199 PyObject * obj0 = 0 ;
52200 PyObject * obj1 = 0 ;
52201 char * kwnames[] = {
52202 (char *) "self",(char *) "otherW", NULL
52203 };
52204
52205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52207 if (!SWIG_IsOK(res1)) {
52208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52209 }
52210 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52211 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52212 if (!SWIG_IsOK(res2)) {
52213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52214 }
52215 arg2 = reinterpret_cast< wxWindow * >(argp2);
52216 {
52217 PyThreadState* __tstate = wxPyBeginAllowThreads();
52218 result = (bool)(arg1)->ResetIfWin(arg2);
52219 wxPyEndAllowThreads(__tstate);
52220 if (PyErr_Occurred()) SWIG_fail;
52221 }
52222 {
52223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52224 }
52225 return resultobj;
52226 fail:
52227 return NULL;
52228 }
52229
52230
52231 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52232 PyObject *resultobj = 0;
52233 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52234 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52235 wxWindow *arg3 = (wxWindow *) 0 ;
52236 bool result;
52237 void *argp1 = 0 ;
52238 int res1 = 0 ;
52239 void *argp2 = 0 ;
52240 int res2 = 0 ;
52241 void *argp3 = 0 ;
52242 int res3 = 0 ;
52243 PyObject * obj0 = 0 ;
52244 PyObject * obj1 = 0 ;
52245 PyObject * obj2 = 0 ;
52246 char * kwnames[] = {
52247 (char *) "self",(char *) "constraints",(char *) "win", NULL
52248 };
52249
52250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52252 if (!SWIG_IsOK(res1)) {
52253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52254 }
52255 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52257 if (!SWIG_IsOK(res2)) {
52258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52259 }
52260 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52261 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52262 if (!SWIG_IsOK(res3)) {
52263 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52264 }
52265 arg3 = reinterpret_cast< wxWindow * >(argp3);
52266 {
52267 PyThreadState* __tstate = wxPyBeginAllowThreads();
52268 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52269 wxPyEndAllowThreads(__tstate);
52270 if (PyErr_Occurred()) SWIG_fail;
52271 }
52272 {
52273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52274 }
52275 return resultobj;
52276 fail:
52277 return NULL;
52278 }
52279
52280
52281 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52282 PyObject *resultobj = 0;
52283 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52284 wxEdge arg2 ;
52285 wxWindow *arg3 = (wxWindow *) 0 ;
52286 wxWindow *arg4 = (wxWindow *) 0 ;
52287 int result;
52288 void *argp1 = 0 ;
52289 int res1 = 0 ;
52290 int val2 ;
52291 int ecode2 = 0 ;
52292 void *argp3 = 0 ;
52293 int res3 = 0 ;
52294 void *argp4 = 0 ;
52295 int res4 = 0 ;
52296 PyObject * obj0 = 0 ;
52297 PyObject * obj1 = 0 ;
52298 PyObject * obj2 = 0 ;
52299 PyObject * obj3 = 0 ;
52300 char * kwnames[] = {
52301 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52302 };
52303
52304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52306 if (!SWIG_IsOK(res1)) {
52307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52308 }
52309 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52310 ecode2 = SWIG_AsVal_int(obj1, &val2);
52311 if (!SWIG_IsOK(ecode2)) {
52312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52313 }
52314 arg2 = static_cast< wxEdge >(val2);
52315 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52316 if (!SWIG_IsOK(res3)) {
52317 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52318 }
52319 arg3 = reinterpret_cast< wxWindow * >(argp3);
52320 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52321 if (!SWIG_IsOK(res4)) {
52322 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52323 }
52324 arg4 = reinterpret_cast< wxWindow * >(argp4);
52325 {
52326 PyThreadState* __tstate = wxPyBeginAllowThreads();
52327 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52328 wxPyEndAllowThreads(__tstate);
52329 if (PyErr_Occurred()) SWIG_fail;
52330 }
52331 resultobj = SWIG_From_int(static_cast< int >(result));
52332 return resultobj;
52333 fail:
52334 return NULL;
52335 }
52336
52337
52338 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52339 PyObject *obj;
52340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52341 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52342 return SWIG_Py_Void();
52343 }
52344
52345 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52346 PyObject *resultobj = 0;
52347 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52348 wxIndividualLayoutConstraint *result = 0 ;
52349 void *argp1 = 0 ;
52350 int res1 = 0 ;
52351 PyObject *swig_obj[1] ;
52352
52353 if (!args) SWIG_fail;
52354 swig_obj[0] = args;
52355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52356 if (!SWIG_IsOK(res1)) {
52357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52358 }
52359 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52360 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52362 return resultobj;
52363 fail:
52364 return NULL;
52365 }
52366
52367
52368 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52369 PyObject *resultobj = 0;
52370 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52371 wxIndividualLayoutConstraint *result = 0 ;
52372 void *argp1 = 0 ;
52373 int res1 = 0 ;
52374 PyObject *swig_obj[1] ;
52375
52376 if (!args) SWIG_fail;
52377 swig_obj[0] = args;
52378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52379 if (!SWIG_IsOK(res1)) {
52380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52381 }
52382 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52383 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52385 return resultobj;
52386 fail:
52387 return NULL;
52388 }
52389
52390
52391 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52392 PyObject *resultobj = 0;
52393 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52394 wxIndividualLayoutConstraint *result = 0 ;
52395 void *argp1 = 0 ;
52396 int res1 = 0 ;
52397 PyObject *swig_obj[1] ;
52398
52399 if (!args) SWIG_fail;
52400 swig_obj[0] = args;
52401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52402 if (!SWIG_IsOK(res1)) {
52403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52404 }
52405 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52406 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52408 return resultobj;
52409 fail:
52410 return NULL;
52411 }
52412
52413
52414 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52415 PyObject *resultobj = 0;
52416 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52417 wxIndividualLayoutConstraint *result = 0 ;
52418 void *argp1 = 0 ;
52419 int res1 = 0 ;
52420 PyObject *swig_obj[1] ;
52421
52422 if (!args) SWIG_fail;
52423 swig_obj[0] = args;
52424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52425 if (!SWIG_IsOK(res1)) {
52426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52427 }
52428 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52429 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52431 return resultobj;
52432 fail:
52433 return NULL;
52434 }
52435
52436
52437 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52438 PyObject *resultobj = 0;
52439 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52440 wxIndividualLayoutConstraint *result = 0 ;
52441 void *argp1 = 0 ;
52442 int res1 = 0 ;
52443 PyObject *swig_obj[1] ;
52444
52445 if (!args) SWIG_fail;
52446 swig_obj[0] = args;
52447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52448 if (!SWIG_IsOK(res1)) {
52449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52450 }
52451 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52452 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52454 return resultobj;
52455 fail:
52456 return NULL;
52457 }
52458
52459
52460 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52461 PyObject *resultobj = 0;
52462 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52463 wxIndividualLayoutConstraint *result = 0 ;
52464 void *argp1 = 0 ;
52465 int res1 = 0 ;
52466 PyObject *swig_obj[1] ;
52467
52468 if (!args) SWIG_fail;
52469 swig_obj[0] = args;
52470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52471 if (!SWIG_IsOK(res1)) {
52472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52473 }
52474 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52475 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52477 return resultobj;
52478 fail:
52479 return NULL;
52480 }
52481
52482
52483 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52484 PyObject *resultobj = 0;
52485 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52486 wxIndividualLayoutConstraint *result = 0 ;
52487 void *argp1 = 0 ;
52488 int res1 = 0 ;
52489 PyObject *swig_obj[1] ;
52490
52491 if (!args) SWIG_fail;
52492 swig_obj[0] = args;
52493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52494 if (!SWIG_IsOK(res1)) {
52495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52496 }
52497 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52498 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52500 return resultobj;
52501 fail:
52502 return NULL;
52503 }
52504
52505
52506 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52507 PyObject *resultobj = 0;
52508 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52509 wxIndividualLayoutConstraint *result = 0 ;
52510 void *argp1 = 0 ;
52511 int res1 = 0 ;
52512 PyObject *swig_obj[1] ;
52513
52514 if (!args) SWIG_fail;
52515 swig_obj[0] = args;
52516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52517 if (!SWIG_IsOK(res1)) {
52518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52519 }
52520 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52521 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52523 return resultobj;
52524 fail:
52525 return NULL;
52526 }
52527
52528
52529 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52530 PyObject *resultobj = 0;
52531 wxLayoutConstraints *result = 0 ;
52532
52533 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52534 {
52535 PyThreadState* __tstate = wxPyBeginAllowThreads();
52536 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52537 wxPyEndAllowThreads(__tstate);
52538 if (PyErr_Occurred()) SWIG_fail;
52539 }
52540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52541 return resultobj;
52542 fail:
52543 return NULL;
52544 }
52545
52546
52547 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52548 PyObject *resultobj = 0;
52549 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52550 void *argp1 = 0 ;
52551 int res1 = 0 ;
52552 PyObject *swig_obj[1] ;
52553
52554 if (!args) SWIG_fail;
52555 swig_obj[0] = args;
52556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52557 if (!SWIG_IsOK(res1)) {
52558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52559 }
52560 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52561 {
52562 PyThreadState* __tstate = wxPyBeginAllowThreads();
52563 delete arg1;
52564
52565 wxPyEndAllowThreads(__tstate);
52566 if (PyErr_Occurred()) SWIG_fail;
52567 }
52568 resultobj = SWIG_Py_Void();
52569 return resultobj;
52570 fail:
52571 return NULL;
52572 }
52573
52574
52575 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52576 PyObject *resultobj = 0;
52577 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52578 wxWindow *arg2 = (wxWindow *) 0 ;
52579 int *arg3 = (int *) 0 ;
52580 bool result;
52581 void *argp1 = 0 ;
52582 int res1 = 0 ;
52583 void *argp2 = 0 ;
52584 int res2 = 0 ;
52585 int temp3 ;
52586 int res3 = SWIG_TMPOBJ ;
52587 PyObject * obj0 = 0 ;
52588 PyObject * obj1 = 0 ;
52589 char * kwnames[] = {
52590 (char *) "self",(char *) "win", NULL
52591 };
52592
52593 arg3 = &temp3;
52594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52596 if (!SWIG_IsOK(res1)) {
52597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52598 }
52599 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52601 if (!SWIG_IsOK(res2)) {
52602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52603 }
52604 arg2 = reinterpret_cast< wxWindow * >(argp2);
52605 {
52606 PyThreadState* __tstate = wxPyBeginAllowThreads();
52607 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52608 wxPyEndAllowThreads(__tstate);
52609 if (PyErr_Occurred()) SWIG_fail;
52610 }
52611 {
52612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52613 }
52614 if (SWIG_IsTmpObj(res3)) {
52615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52616 } else {
52617 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52619 }
52620 return resultobj;
52621 fail:
52622 return NULL;
52623 }
52624
52625
52626 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52627 PyObject *resultobj = 0;
52628 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52629 bool result;
52630 void *argp1 = 0 ;
52631 int res1 = 0 ;
52632 PyObject *swig_obj[1] ;
52633
52634 if (!args) SWIG_fail;
52635 swig_obj[0] = args;
52636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52637 if (!SWIG_IsOK(res1)) {
52638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52639 }
52640 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52641 {
52642 PyThreadState* __tstate = wxPyBeginAllowThreads();
52643 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52644 wxPyEndAllowThreads(__tstate);
52645 if (PyErr_Occurred()) SWIG_fail;
52646 }
52647 {
52648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52649 }
52650 return resultobj;
52651 fail:
52652 return NULL;
52653 }
52654
52655
52656 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52657 PyObject *obj;
52658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52659 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52660 return SWIG_Py_Void();
52661 }
52662
52663 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52664 return SWIG_Python_InitShadowInstance(args);
52665 }
52666
52667 static PyMethodDef SwigMethods[] = {
52668 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52669 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52670 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52671 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52672 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52673 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52674 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52675 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52676 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52678 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52688 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52689 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52690 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52692 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52693 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52694 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52695 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52696 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52697 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52698 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52700 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52702 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52706 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52707 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52708 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52709 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52710 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52711 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52712 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52714 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52718 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52720 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52721 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52722 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52723 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52724 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52725 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52727 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52728 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52729 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52730 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52731 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52732 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52733 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52734 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52735 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52736 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52738 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52740 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52742 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52743 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52745 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52747 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52748 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52749 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52750 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52754 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52769 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52770 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52771 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52772 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52773 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52774 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52775 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52776 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52778 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52779 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52780 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52785 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52786 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52787 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52788 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52795 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52802 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52803 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52804 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52805 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52807 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52808 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52809 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52811 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52812 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52813 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52814 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52819 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52820 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52821 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52822 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52823 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52824 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52827 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52828 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52829 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52831 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52832 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52834 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52835 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52836 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52837 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52838 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52839 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52840 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52841 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52842 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52843 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52844 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52849 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52855 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52856 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52857 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52858 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52860 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52863 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52865 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52868 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52869 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52870 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52873 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52874 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52875 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52879 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52880 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52881 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52885 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52890 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52891 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52892 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52893 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52894 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52895 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52896 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52902 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52903 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52905 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52906 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52907 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52913 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52914 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52916 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52917 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52918 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52919 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52920 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52921 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52922 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52923 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52925 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52926 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52927 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52928 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52929 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52930 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52931 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52932 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52934 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52943 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52955 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52956 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52971 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52972 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52973 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52974 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52977 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52979 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52981 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52983 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52985 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52988 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52989 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52990 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52991 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52993 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53010 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53011 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53017 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53018 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53019 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53020 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53021 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53022 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53023 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53024 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53025 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53026 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53027 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53028 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53029 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53030 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53031 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53032 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53033 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53034 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53035 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53036 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53037 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53038 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53039 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53040 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53041 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53042 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53043 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53044 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53045 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53046 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53047 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53048 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53049 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53050 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53051 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53053 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53054 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53055 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53056 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53059 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53063 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53067 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53068 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53069 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53070 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53072 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53073 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53075 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53077 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53079 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53081 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53082 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53083 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53085 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53086 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53088 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53089 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53090 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53092 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53093 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53094 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53096 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53098 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53099 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53100 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53102 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53104 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53105 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53107 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53108 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53109 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53111 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53112 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53113 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53114 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53115 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53117 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53118 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53121 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53122 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53124 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53125 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53128 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53129 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53131 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53137 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53138 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53139 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53140 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53141 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53142 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53143 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53144 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53145 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53146 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53147 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53148 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53149 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53150 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53151 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53152 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53153 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53154 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53155 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53156 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53157 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53158 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53159 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53160 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53162 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53163 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53164 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53165 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53166 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53167 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53168 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53169 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53170 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53171 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53172 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53173 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53174 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53175 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53176 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53177 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53178 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53179 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53180 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53181 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53182 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53183 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53184 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53185 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53186 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53187 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53188 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53189 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53190 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53191 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53192 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53193 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53195 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53196 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53198 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53199 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53200 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53201 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53203 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53204 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53205 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53206 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53207 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53208 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53209 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53210 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53211 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53213 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53214 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53215 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53216 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53217 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53218 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53219 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53220 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53221 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53222 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53223 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53224 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53225 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53226 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53227 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53228 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53229 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53230 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53231 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53232 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53233 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53234 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53235 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53236 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53237 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53238 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53239 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53240 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53242 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53243 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53246 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53247 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53248 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53249 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53250 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53251 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53253 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53254 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53257 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53258 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53260 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53261 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53263 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53264 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53266 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53267 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53268 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53270 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53272 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53273 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53275 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53276 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53277 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53279 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53280 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53281 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53283 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53284 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53286 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53287 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53288 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53289 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53290 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53293 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53295 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53297 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53298 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53299 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53302 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53303 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53304 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53306 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53307 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53308 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53310 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53311 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53312 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53313 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53314 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53315 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53317 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53318 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53319 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53320 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53321 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53322 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53323 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53324 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53330 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53332 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53334 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53335 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53336 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53337 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53338 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53339 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53341 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53342 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53343 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53344 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53345 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53346 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53349 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53350 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53351 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53354 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53355 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53356 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53357 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53358 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53360 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53362 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53365 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53367 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53368 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53370 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53371 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53372 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53374 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53375 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53376 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53378 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53380 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53381 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53382 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53384 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53386 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53388 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53389 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53391 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53392 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53394 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53396 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53397 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53398 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53400 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53402 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53403 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53404 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53406 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53408 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53409 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53410 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53411 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53413 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53415 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53417 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53419 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53420 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53422 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53423 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53424 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53425 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53426 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53427 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53428 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53429 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53431 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53433 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53435 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53437 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53439 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53441 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53442 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53443 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53444 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53445 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53446 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53452 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53453 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53454 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53455 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53456 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53457 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53458 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53460 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53462 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53463 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53465 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53466 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53467 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53468 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53470 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53471 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53472 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53473 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53475 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53476 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53478 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53479 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53480 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53482 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53484 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53485 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53486 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53487 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53488 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53490 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53491 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53492 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53493 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53495 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53496 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53497 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53498 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53499 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53500 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53501 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53502 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53503 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53504 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53506 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53509 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53510 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53511 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53513 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53515 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53517 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53519 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53520 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53530 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53531 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53535 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53536 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53537 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53538 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53539 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53540 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53541 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53542 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53543 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53544 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53545 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53546 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53547 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53548 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53549 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53551 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53552 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53555 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53556 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53561 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53562 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53565 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53566 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53567 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53568 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53571 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53572 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53573 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53575 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53577 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53578 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53579 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53581 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53583 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53585 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53588 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53589 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53590 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53591 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53592 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53593 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53594 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53600 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53601 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53602 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53603 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53610 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53616 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53617 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53618 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53619 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53620 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53622 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53632 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53633 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53634 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53635 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53638 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53639 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53640 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53641 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53643 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53644 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53648 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53654 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53655 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53656 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53657 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53659 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53660 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53662 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53665 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53667 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53668 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53669 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53678 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53682 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53684 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53694 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53695 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53696 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53697 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53701 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53704 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53706 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53709 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53711 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53712 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53715 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53717 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53718 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53719 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53720 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53721 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53726 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53727 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53728 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53730 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53731 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53732 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53734 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53736 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53737 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53738 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53740 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53741 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53744 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53752 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53759 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53767 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53770 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53771 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53784 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53786 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53788 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53789 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53791 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53793 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53794 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53796 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53797 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53798 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53802 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53821 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53822 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53824 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53826 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53827 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53828 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53830 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53831 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53834 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53835 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53837 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53838 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53840 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53843 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53844 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53846 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53848 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53850 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53851 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53853 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53854 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53857 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53859 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53861 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53863 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53866 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53868 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53869 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53870 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53872 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53873 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53874 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53876 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53879 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53881 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53882 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53886 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53890 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53891 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53893 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53897 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53899 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53901 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53902 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53903 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53904 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53908 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53909 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53910 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53911 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53913 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53914 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53919 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53920 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53921 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53922 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53923 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53925 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53927 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53929 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53930 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53932 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53934 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53937 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53938 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53939 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53941 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53942 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53943 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53957 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53958 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53959 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53960 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53961 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53962 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53968 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53969 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53973 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53974 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53976 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53977 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53979 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53981 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53982 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53984 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53985 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53986 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53992 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53993 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53994 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53995 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53996 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53997 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54004 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54006 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54007 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54008 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54009 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54010 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54011 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54013 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54017 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54018 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54019 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54020 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54021 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54022 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54023 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54025 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54026 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54027 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54033 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54034 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54035 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54037 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54038 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54039 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54045 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54046 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54047 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54048 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54049 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54053 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54054 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54059 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54060 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54062 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54063 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54068 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54070 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54071 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54072 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54073 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54074 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54079 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54080 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54089 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54090 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54091 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54092 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54095 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54097 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54098 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54099 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54100 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54102 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54107 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54108 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54109 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54110 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54111 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54112 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54113 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54114 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54115 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54116 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54117 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54119 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54120 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54121 { NULL, NULL, 0, NULL }
54122 };
54123
54124
54125 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54126
54127 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54128 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54129 }
54130 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54131 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54132 }
54133 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54134 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54135 }
54136 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54137 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54138 }
54139 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54140 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54141 }
54142 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54143 return (void *)((wxSizer *) ((wxGridSizer *) x));
54144 }
54145 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54146 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54147 }
54148 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54149 return (void *)((wxSizer *) ((wxPySizer *) x));
54150 }
54151 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54152 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54153 }
54154 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54155 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54156 }
54157 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54158 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54159 }
54160 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54161 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54162 }
54163 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54164 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54165 }
54166 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54167 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54168 }
54169 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54170 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54171 }
54172 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54173 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54174 }
54175 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54176 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54177 }
54178 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54179 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54180 }
54181 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54182 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54183 }
54184 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54185 return (void *)((wxEvent *) ((wxPyEvent *) x));
54186 }
54187 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54188 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54189 }
54190 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54191 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54192 }
54193 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54194 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54195 }
54196 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54197 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54198 }
54199 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54200 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54201 }
54202 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54203 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54204 }
54205 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54206 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54207 }
54208 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54209 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54210 }
54211 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54212 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54213 }
54214 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54215 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54216 }
54217 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54218 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54219 }
54220 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54221 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54222 }
54223 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54224 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54225 }
54226 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54227 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54228 }
54229 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54230 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54231 }
54232 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54233 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54234 }
54235 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54236 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54237 }
54238 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54239 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54240 }
54241 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54242 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54243 }
54244 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54245 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54246 }
54247 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54248 return (void *)((wxEvent *) ((wxShowEvent *) x));
54249 }
54250 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54251 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54252 }
54253 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54254 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54255 }
54256 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54257 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54258 }
54259 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54260 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54261 }
54262 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54263 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54264 }
54265 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54266 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54267 }
54268 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54269 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54270 }
54271 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54272 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54273 }
54274 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54275 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54276 }
54277 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54278 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54279 }
54280 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54281 return (void *)((wxControl *) ((wxControlWithItems *) x));
54282 }
54283 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54284 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54285 }
54286 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54287 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54288 }
54289 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54290 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54291 }
54292 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54293 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54294 }
54295 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54296 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54297 }
54298 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54299 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54300 }
54301 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54302 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54303 }
54304 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54305 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54306 }
54307 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54308 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54309 }
54310 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54311 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54312 }
54313 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54314 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54315 }
54316 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54317 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54318 }
54319 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54320 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54321 }
54322 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54323 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54324 }
54325 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54326 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54327 }
54328 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54329 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54330 }
54331 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54332 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54333 }
54334 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54335 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54336 }
54337 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54338 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54339 }
54340 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54341 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54342 }
54343 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54344 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54345 }
54346 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54347 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54348 }
54349 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54350 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54351 }
54352 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54353 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54354 }
54355 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54356 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54357 }
54358 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54359 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54360 }
54361 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54362 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54363 }
54364 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54365 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54366 }
54367 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54368 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54369 }
54370 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54371 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54372 }
54373 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54374 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54375 }
54376 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54377 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54378 }
54379 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54380 return (void *)((wxObject *) ((wxSizerItem *) x));
54381 }
54382 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54383 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54384 }
54385 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54386 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54387 }
54388 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54389 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54390 }
54391 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54392 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54393 }
54394 static void *_p_wxSizerTo_p_wxObject(void *x) {
54395 return (void *)((wxObject *) ((wxSizer *) x));
54396 }
54397 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54398 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54399 }
54400 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54401 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54402 }
54403 static void *_p_wxEventTo_p_wxObject(void *x) {
54404 return (void *)((wxObject *) ((wxEvent *) x));
54405 }
54406 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54407 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54408 }
54409 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54410 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54411 }
54412 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54413 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54414 }
54415 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54416 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54417 }
54418 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54419 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54420 }
54421 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54422 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54423 }
54424 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54425 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54426 }
54427 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54428 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54429 }
54430 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54431 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54432 }
54433 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54434 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54435 }
54436 static void *_p_wxControlTo_p_wxObject(void *x) {
54437 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54438 }
54439 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54440 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54441 }
54442 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54443 return (void *)((wxObject *) ((wxFSFile *) x));
54444 }
54445 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54446 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54447 }
54448 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54449 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54450 }
54451 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54452 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54453 }
54454 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54455 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54456 }
54457 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54458 return (void *)((wxObject *) ((wxMenuItem *) x));
54459 }
54460 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54461 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54462 }
54463 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54464 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54465 }
54466 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54467 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54468 }
54469 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54470 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54471 }
54472 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54473 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54474 }
54475 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54476 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54477 }
54478 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54479 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54480 }
54481 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54482 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54483 }
54484 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54485 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54486 }
54487 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54488 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54489 }
54490 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54491 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54492 }
54493 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54494 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54495 }
54496 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54497 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54498 }
54499 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54500 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54501 }
54502 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54503 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54504 }
54505 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54506 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54507 }
54508 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54509 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54510 }
54511 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54512 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54513 }
54514 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54515 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54516 }
54517 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54518 return (void *)((wxObject *) ((wxImageHandler *) x));
54519 }
54520 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54521 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54522 }
54523 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54524 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54525 }
54526 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54527 return (void *)((wxObject *) ((wxEvtHandler *) x));
54528 }
54529 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54530 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54531 }
54532 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54533 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54534 }
54535 static void *_p_wxImageTo_p_wxObject(void *x) {
54536 return (void *)((wxObject *) ((wxImage *) x));
54537 }
54538 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54539 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54540 }
54541 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54542 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54543 }
54544 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54545 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54546 }
54547 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54548 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54549 }
54550 static void *_p_wxWindowTo_p_wxObject(void *x) {
54551 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54552 }
54553 static void *_p_wxMenuTo_p_wxObject(void *x) {
54554 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54555 }
54556 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54557 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54558 }
54559 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54560 return (void *)((wxObject *) ((wxFileSystem *) x));
54561 }
54562 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54563 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54564 }
54565 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54566 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54567 }
54568 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54569 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54570 }
54571 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54572 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54573 }
54574 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54575 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54576 }
54577 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54578 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54579 }
54580 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54581 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54582 }
54583 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54584 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54585 }
54586 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54587 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54588 }
54589 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54590 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54591 }
54592 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54593 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54594 }
54595 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54596 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54597 }
54598 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54599 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54600 }
54601 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54602 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54603 }
54604 static void *_p_wxControlTo_p_wxWindow(void *x) {
54605 return (void *)((wxWindow *) ((wxControl *) x));
54606 }
54607 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54608 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54609 }
54610 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54611 return (void *)((wxWindow *) ((wxMenuBar *) x));
54612 }
54613 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54614 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54615 }
54616 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54617 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54618 }
54619 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54620 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54621 }
54622 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54623 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54624 }
54625 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54626 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54627 }
54628 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54629 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54630 }
54631 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54632 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54633 }
54634 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54635 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54636 }
54637 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54638 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54639 }
54640 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54641 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54642 }
54643 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54644 return (void *)((wxValidator *) ((wxPyValidator *) x));
54645 }
54646 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54647 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54648 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};
54649 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54650 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54651 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54652 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54653 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54654 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54655 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54656 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54657 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54658 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54659 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54660 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54661 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54662 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54663 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54664 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54665 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54666 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54667 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54668 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54669 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54670 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54671 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54672 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54673 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54674 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54675 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54676 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54677 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54678 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54679 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54680 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54681 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54682 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54683 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54684 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54685 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54686 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54687 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54688 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54689 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54690 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54691 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54692 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54693 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54694 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54695 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54696 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54697 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54698 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54699 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54700 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54701 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54702 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54703 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54704 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54705 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54706 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54707 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54708 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54709 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54710 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54711 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54712 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54713 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54714 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54715 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54716 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54717 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54718 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54719 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54720 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54721 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54722 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54723 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54724 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54725 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54726 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54727 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54728 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54729 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54730 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54731 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54732 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54733 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54734 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54735 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54736 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54737 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54739 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54740 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54777
54778 static swig_type_info *swig_type_initial[] = {
54779 &_swigt__p_buffer,
54780 &_swigt__p_char,
54781 &_swigt__p_form_ops_t,
54782 &_swigt__p_int,
54783 &_swigt__p_long,
54784 &_swigt__p_unsigned_char,
54785 &_swigt__p_unsigned_int,
54786 &_swigt__p_unsigned_long,
54787 &_swigt__p_wxANIHandler,
54788 &_swigt__p_wxAcceleratorEntry,
54789 &_swigt__p_wxAcceleratorTable,
54790 &_swigt__p_wxActivateEvent,
54791 &_swigt__p_wxAppTraits,
54792 &_swigt__p_wxArrayString,
54793 &_swigt__p_wxBMPHandler,
54794 &_swigt__p_wxBitmap,
54795 &_swigt__p_wxBoxSizer,
54796 &_swigt__p_wxButton,
54797 &_swigt__p_wxCURHandler,
54798 &_swigt__p_wxCaret,
54799 &_swigt__p_wxChildFocusEvent,
54800 &_swigt__p_wxClipboardTextEvent,
54801 &_swigt__p_wxCloseEvent,
54802 &_swigt__p_wxColour,
54803 &_swigt__p_wxCommandEvent,
54804 &_swigt__p_wxContextMenuEvent,
54805 &_swigt__p_wxControl,
54806 &_swigt__p_wxControlWithItems,
54807 &_swigt__p_wxCursor,
54808 &_swigt__p_wxDC,
54809 &_swigt__p_wxDateEvent,
54810 &_swigt__p_wxDateTime,
54811 &_swigt__p_wxDisplayChangedEvent,
54812 &_swigt__p_wxDropFilesEvent,
54813 &_swigt__p_wxDuplexMode,
54814 &_swigt__p_wxEraseEvent,
54815 &_swigt__p_wxEvent,
54816 &_swigt__p_wxEventLoop,
54817 &_swigt__p_wxEventLoopActivator,
54818 &_swigt__p_wxEvtHandler,
54819 &_swigt__p_wxFSFile,
54820 &_swigt__p_wxFileSystem,
54821 &_swigt__p_wxFileSystemHandler,
54822 &_swigt__p_wxFlexGridSizer,
54823 &_swigt__p_wxFocusEvent,
54824 &_swigt__p_wxFont,
54825 &_swigt__p_wxFrame,
54826 &_swigt__p_wxGBPosition,
54827 &_swigt__p_wxGBSizerItem,
54828 &_swigt__p_wxGBSpan,
54829 &_swigt__p_wxGIFHandler,
54830 &_swigt__p_wxGridBagSizer,
54831 &_swigt__p_wxGridSizer,
54832 &_swigt__p_wxHelpEvent__Origin,
54833 &_swigt__p_wxICOHandler,
54834 &_swigt__p_wxIconizeEvent,
54835 &_swigt__p_wxIdleEvent,
54836 &_swigt__p_wxImage,
54837 &_swigt__p_wxImageHandler,
54838 &_swigt__p_wxImageHistogram,
54839 &_swigt__p_wxImage_HSVValue,
54840 &_swigt__p_wxImage_RGBValue,
54841 &_swigt__p_wxIndividualLayoutConstraint,
54842 &_swigt__p_wxInitDialogEvent,
54843 &_swigt__p_wxInputStream,
54844 &_swigt__p_wxInternetFSHandler,
54845 &_swigt__p_wxItemContainer,
54846 &_swigt__p_wxJPEGHandler,
54847 &_swigt__p_wxKeyEvent,
54848 &_swigt__p_wxLayoutConstraints,
54849 &_swigt__p_wxMaximizeEvent,
54850 &_swigt__p_wxMemoryFSHandler,
54851 &_swigt__p_wxMenu,
54852 &_swigt__p_wxMenuBar,
54853 &_swigt__p_wxMenuBarBase,
54854 &_swigt__p_wxMenuEvent,
54855 &_swigt__p_wxMenuItem,
54856 &_swigt__p_wxMouseCaptureChangedEvent,
54857 &_swigt__p_wxMouseEvent,
54858 &_swigt__p_wxMoveEvent,
54859 &_swigt__p_wxNavigationKeyEvent,
54860 &_swigt__p_wxNcPaintEvent,
54861 &_swigt__p_wxNotifyEvent,
54862 &_swigt__p_wxObject,
54863 &_swigt__p_wxOutputStream,
54864 &_swigt__p_wxPCXHandler,
54865 &_swigt__p_wxPNGHandler,
54866 &_swigt__p_wxPNMHandler,
54867 &_swigt__p_wxPaintEvent,
54868 &_swigt__p_wxPaletteChangedEvent,
54869 &_swigt__p_wxPaperSize,
54870 &_swigt__p_wxPoint,
54871 &_swigt__p_wxPoint2D,
54872 &_swigt__p_wxPropagateOnce,
54873 &_swigt__p_wxPropagationDisabler,
54874 &_swigt__p_wxPyApp,
54875 &_swigt__p_wxPyCommandEvent,
54876 &_swigt__p_wxPyDropTarget,
54877 &_swigt__p_wxPyEvent,
54878 &_swigt__p_wxPyFileSystemHandler,
54879 &_swigt__p_wxPyImageHandler,
54880 &_swigt__p_wxPyInputStream,
54881 &_swigt__p_wxPySizer,
54882 &_swigt__p_wxPyValidator,
54883 &_swigt__p_wxQuantize,
54884 &_swigt__p_wxQueryNewPaletteEvent,
54885 &_swigt__p_wxRealPoint,
54886 &_swigt__p_wxRect,
54887 &_swigt__p_wxRegion,
54888 &_swigt__p_wxScrollEvent,
54889 &_swigt__p_wxScrollWinEvent,
54890 &_swigt__p_wxSetCursorEvent,
54891 &_swigt__p_wxShowEvent,
54892 &_swigt__p_wxSize,
54893 &_swigt__p_wxSizeEvent,
54894 &_swigt__p_wxSizer,
54895 &_swigt__p_wxSizerItem,
54896 &_swigt__p_wxStaticBox,
54897 &_swigt__p_wxStaticBoxSizer,
54898 &_swigt__p_wxStdDialogButtonSizer,
54899 &_swigt__p_wxSysColourChangedEvent,
54900 &_swigt__p_wxTIFFHandler,
54901 &_swigt__p_wxToolTip,
54902 &_swigt__p_wxUpdateUIEvent,
54903 &_swigt__p_wxValidator,
54904 &_swigt__p_wxVisualAttributes,
54905 &_swigt__p_wxWindow,
54906 &_swigt__p_wxWindowCreateEvent,
54907 &_swigt__p_wxWindowDestroyEvent,
54908 &_swigt__p_wxXPMHandler,
54909 &_swigt__p_wxZipFSHandler,
54910 };
54911
54912 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54913 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54914 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54915 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54916 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54917 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54918 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54919 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54920 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54921 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54922 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54923 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54924 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54925 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54926 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}};
54927 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54928 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}};
54929 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54930 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}};
54931 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54932 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54933 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54934 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54935 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54936 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}};
54937 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54938 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}};
54939 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54940 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54941 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54942 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54943 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54944 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54945 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54946 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54947 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54948 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_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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}};
54949 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54950 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54951 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}};
54952 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54953 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54954 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}};
54955 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}};
54956 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54957 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54958 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54959 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54960 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54961 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54962 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54963 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54964 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}};
54965 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
54966 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}};
54967 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54968 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54969 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54970 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}};
54971 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54972 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54973 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54974 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54975 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54976 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54977 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54978 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}};
54979 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54980 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54981 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54982 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54983 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54984 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54985 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54986 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54987 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54988 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54989 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54990 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54991 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54992 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54993 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54994 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54995 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_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_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_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_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_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_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}};
54996 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54997 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54998 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54999 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55000 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55001 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55002 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55003 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55006 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55007 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55008 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55009 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55010 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55011 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55012 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55013 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55014 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55015 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55016 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55017 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55018 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55019 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55020 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55021 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55022 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55023 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55024 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55025 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55026 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55027 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}};
55028 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}};
55029 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55030 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55031 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55032 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55034 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55035 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55036 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}};
55037 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55038 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}};
55039 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55042 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55043
55044 static swig_cast_info *swig_cast_initial[] = {
55045 _swigc__p_buffer,
55046 _swigc__p_char,
55047 _swigc__p_form_ops_t,
55048 _swigc__p_int,
55049 _swigc__p_long,
55050 _swigc__p_unsigned_char,
55051 _swigc__p_unsigned_int,
55052 _swigc__p_unsigned_long,
55053 _swigc__p_wxANIHandler,
55054 _swigc__p_wxAcceleratorEntry,
55055 _swigc__p_wxAcceleratorTable,
55056 _swigc__p_wxActivateEvent,
55057 _swigc__p_wxAppTraits,
55058 _swigc__p_wxArrayString,
55059 _swigc__p_wxBMPHandler,
55060 _swigc__p_wxBitmap,
55061 _swigc__p_wxBoxSizer,
55062 _swigc__p_wxButton,
55063 _swigc__p_wxCURHandler,
55064 _swigc__p_wxCaret,
55065 _swigc__p_wxChildFocusEvent,
55066 _swigc__p_wxClipboardTextEvent,
55067 _swigc__p_wxCloseEvent,
55068 _swigc__p_wxColour,
55069 _swigc__p_wxCommandEvent,
55070 _swigc__p_wxContextMenuEvent,
55071 _swigc__p_wxControl,
55072 _swigc__p_wxControlWithItems,
55073 _swigc__p_wxCursor,
55074 _swigc__p_wxDC,
55075 _swigc__p_wxDateEvent,
55076 _swigc__p_wxDateTime,
55077 _swigc__p_wxDisplayChangedEvent,
55078 _swigc__p_wxDropFilesEvent,
55079 _swigc__p_wxDuplexMode,
55080 _swigc__p_wxEraseEvent,
55081 _swigc__p_wxEvent,
55082 _swigc__p_wxEventLoop,
55083 _swigc__p_wxEventLoopActivator,
55084 _swigc__p_wxEvtHandler,
55085 _swigc__p_wxFSFile,
55086 _swigc__p_wxFileSystem,
55087 _swigc__p_wxFileSystemHandler,
55088 _swigc__p_wxFlexGridSizer,
55089 _swigc__p_wxFocusEvent,
55090 _swigc__p_wxFont,
55091 _swigc__p_wxFrame,
55092 _swigc__p_wxGBPosition,
55093 _swigc__p_wxGBSizerItem,
55094 _swigc__p_wxGBSpan,
55095 _swigc__p_wxGIFHandler,
55096 _swigc__p_wxGridBagSizer,
55097 _swigc__p_wxGridSizer,
55098 _swigc__p_wxHelpEvent__Origin,
55099 _swigc__p_wxICOHandler,
55100 _swigc__p_wxIconizeEvent,
55101 _swigc__p_wxIdleEvent,
55102 _swigc__p_wxImage,
55103 _swigc__p_wxImageHandler,
55104 _swigc__p_wxImageHistogram,
55105 _swigc__p_wxImage_HSVValue,
55106 _swigc__p_wxImage_RGBValue,
55107 _swigc__p_wxIndividualLayoutConstraint,
55108 _swigc__p_wxInitDialogEvent,
55109 _swigc__p_wxInputStream,
55110 _swigc__p_wxInternetFSHandler,
55111 _swigc__p_wxItemContainer,
55112 _swigc__p_wxJPEGHandler,
55113 _swigc__p_wxKeyEvent,
55114 _swigc__p_wxLayoutConstraints,
55115 _swigc__p_wxMaximizeEvent,
55116 _swigc__p_wxMemoryFSHandler,
55117 _swigc__p_wxMenu,
55118 _swigc__p_wxMenuBar,
55119 _swigc__p_wxMenuBarBase,
55120 _swigc__p_wxMenuEvent,
55121 _swigc__p_wxMenuItem,
55122 _swigc__p_wxMouseCaptureChangedEvent,
55123 _swigc__p_wxMouseEvent,
55124 _swigc__p_wxMoveEvent,
55125 _swigc__p_wxNavigationKeyEvent,
55126 _swigc__p_wxNcPaintEvent,
55127 _swigc__p_wxNotifyEvent,
55128 _swigc__p_wxObject,
55129 _swigc__p_wxOutputStream,
55130 _swigc__p_wxPCXHandler,
55131 _swigc__p_wxPNGHandler,
55132 _swigc__p_wxPNMHandler,
55133 _swigc__p_wxPaintEvent,
55134 _swigc__p_wxPaletteChangedEvent,
55135 _swigc__p_wxPaperSize,
55136 _swigc__p_wxPoint,
55137 _swigc__p_wxPoint2D,
55138 _swigc__p_wxPropagateOnce,
55139 _swigc__p_wxPropagationDisabler,
55140 _swigc__p_wxPyApp,
55141 _swigc__p_wxPyCommandEvent,
55142 _swigc__p_wxPyDropTarget,
55143 _swigc__p_wxPyEvent,
55144 _swigc__p_wxPyFileSystemHandler,
55145 _swigc__p_wxPyImageHandler,
55146 _swigc__p_wxPyInputStream,
55147 _swigc__p_wxPySizer,
55148 _swigc__p_wxPyValidator,
55149 _swigc__p_wxQuantize,
55150 _swigc__p_wxQueryNewPaletteEvent,
55151 _swigc__p_wxRealPoint,
55152 _swigc__p_wxRect,
55153 _swigc__p_wxRegion,
55154 _swigc__p_wxScrollEvent,
55155 _swigc__p_wxScrollWinEvent,
55156 _swigc__p_wxSetCursorEvent,
55157 _swigc__p_wxShowEvent,
55158 _swigc__p_wxSize,
55159 _swigc__p_wxSizeEvent,
55160 _swigc__p_wxSizer,
55161 _swigc__p_wxSizerItem,
55162 _swigc__p_wxStaticBox,
55163 _swigc__p_wxStaticBoxSizer,
55164 _swigc__p_wxStdDialogButtonSizer,
55165 _swigc__p_wxSysColourChangedEvent,
55166 _swigc__p_wxTIFFHandler,
55167 _swigc__p_wxToolTip,
55168 _swigc__p_wxUpdateUIEvent,
55169 _swigc__p_wxValidator,
55170 _swigc__p_wxVisualAttributes,
55171 _swigc__p_wxWindow,
55172 _swigc__p_wxWindowCreateEvent,
55173 _swigc__p_wxWindowDestroyEvent,
55174 _swigc__p_wxXPMHandler,
55175 _swigc__p_wxZipFSHandler,
55176 };
55177
55178
55179 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55180
55181 static swig_const_info swig_const_table[] = {
55182 {0, 0, 0, 0.0, 0, 0}};
55183
55184 #ifdef __cplusplus
55185 }
55186 #endif
55187 /* -----------------------------------------------------------------------------
55188 * Type initialization:
55189 * This problem is tough by the requirement that no dynamic
55190 * memory is used. Also, since swig_type_info structures store pointers to
55191 * swig_cast_info structures and swig_cast_info structures store pointers back
55192 * to swig_type_info structures, we need some lookup code at initialization.
55193 * The idea is that swig generates all the structures that are needed.
55194 * The runtime then collects these partially filled structures.
55195 * The SWIG_InitializeModule function takes these initial arrays out of
55196 * swig_module, and does all the lookup, filling in the swig_module.types
55197 * array with the correct data and linking the correct swig_cast_info
55198 * structures together.
55199 *
55200 * The generated swig_type_info structures are assigned staticly to an initial
55201 * array. We just loop though that array, and handle each type individually.
55202 * First we lookup if this type has been already loaded, and if so, use the
55203 * loaded structure instead of the generated one. Then we have to fill in the
55204 * cast linked list. The cast data is initially stored in something like a
55205 * two-dimensional array. Each row corresponds to a type (there are the same
55206 * number of rows as there are in the swig_type_initial array). Each entry in
55207 * a column is one of the swig_cast_info structures for that type.
55208 * The cast_initial array is actually an array of arrays, because each row has
55209 * a variable number of columns. So to actually build the cast linked list,
55210 * we find the array of casts associated with the type, and loop through it
55211 * adding the casts to the list. The one last trick we need to do is making
55212 * sure the type pointer in the swig_cast_info struct is correct.
55213 *
55214 * First off, we lookup the cast->type name to see if it is already loaded.
55215 * There are three cases to handle:
55216 * 1) If the cast->type has already been loaded AND the type we are adding
55217 * casting info to has not been loaded (it is in this module), THEN we
55218 * replace the cast->type pointer with the type pointer that has already
55219 * been loaded.
55220 * 2) If BOTH types (the one we are adding casting info to, and the
55221 * cast->type) are loaded, THEN the cast info has already been loaded by
55222 * the previous module so we just ignore it.
55223 * 3) Finally, if cast->type has not already been loaded, then we add that
55224 * swig_cast_info to the linked list (because the cast->type) pointer will
55225 * be correct.
55226 * ----------------------------------------------------------------------------- */
55227
55228 #ifdef __cplusplus
55229 extern "C" {
55230 #if 0
55231 } /* c-mode */
55232 #endif
55233 #endif
55234
55235 #if 0
55236 #define SWIGRUNTIME_DEBUG
55237 #endif
55238
55239 SWIGRUNTIME void
55240 SWIG_InitializeModule(void *clientdata) {
55241 size_t i;
55242 swig_module_info *module_head;
55243 static int init_run = 0;
55244
55245 clientdata = clientdata;
55246
55247 if (init_run) return;
55248 init_run = 1;
55249
55250 /* Initialize the swig_module */
55251 swig_module.type_initial = swig_type_initial;
55252 swig_module.cast_initial = swig_cast_initial;
55253
55254 /* Try and load any already created modules */
55255 module_head = SWIG_GetModule(clientdata);
55256 if (module_head) {
55257 swig_module.next = module_head->next;
55258 module_head->next = &swig_module;
55259 } else {
55260 /* This is the first module loaded */
55261 swig_module.next = &swig_module;
55262 SWIG_SetModule(clientdata, &swig_module);
55263 }
55264
55265 /* Now work on filling in swig_module.types */
55266 #ifdef SWIGRUNTIME_DEBUG
55267 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55268 #endif
55269 for (i = 0; i < swig_module.size; ++i) {
55270 swig_type_info *type = 0;
55271 swig_type_info *ret;
55272 swig_cast_info *cast;
55273
55274 #ifdef SWIGRUNTIME_DEBUG
55275 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55276 #endif
55277
55278 /* if there is another module already loaded */
55279 if (swig_module.next != &swig_module) {
55280 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55281 }
55282 if (type) {
55283 /* Overwrite clientdata field */
55284 #ifdef SWIGRUNTIME_DEBUG
55285 printf("SWIG_InitializeModule: found type %s\n", type->name);
55286 #endif
55287 if (swig_module.type_initial[i]->clientdata) {
55288 type->clientdata = swig_module.type_initial[i]->clientdata;
55289 #ifdef SWIGRUNTIME_DEBUG
55290 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55291 #endif
55292 }
55293 } else {
55294 type = swig_module.type_initial[i];
55295 }
55296
55297 /* Insert casting types */
55298 cast = swig_module.cast_initial[i];
55299 while (cast->type) {
55300 /* Don't need to add information already in the list */
55301 ret = 0;
55302 #ifdef SWIGRUNTIME_DEBUG
55303 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55304 #endif
55305 if (swig_module.next != &swig_module) {
55306 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55307 #ifdef SWIGRUNTIME_DEBUG
55308 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55309 #endif
55310 }
55311 if (ret) {
55312 if (type == swig_module.type_initial[i]) {
55313 #ifdef SWIGRUNTIME_DEBUG
55314 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55315 #endif
55316 cast->type = ret;
55317 ret = 0;
55318 } else {
55319 /* Check for casting already in the list */
55320 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55321 #ifdef SWIGRUNTIME_DEBUG
55322 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55323 #endif
55324 if (!ocast) ret = 0;
55325 }
55326 }
55327
55328 if (!ret) {
55329 #ifdef SWIGRUNTIME_DEBUG
55330 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55331 #endif
55332 if (type->cast) {
55333 type->cast->prev = cast;
55334 cast->next = type->cast;
55335 }
55336 type->cast = cast;
55337 }
55338 cast++;
55339 }
55340 /* Set entry in modules->types array equal to the type */
55341 swig_module.types[i] = type;
55342 }
55343 swig_module.types[i] = 0;
55344
55345 #ifdef SWIGRUNTIME_DEBUG
55346 printf("**** SWIG_InitializeModule: Cast List ******\n");
55347 for (i = 0; i < swig_module.size; ++i) {
55348 int j = 0;
55349 swig_cast_info *cast = swig_module.cast_initial[i];
55350 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55351 while (cast->type) {
55352 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55353 cast++;
55354 ++j;
55355 }
55356 printf("---- Total casts: %d\n",j);
55357 }
55358 printf("**** SWIG_InitializeModule: Cast List ******\n");
55359 #endif
55360 }
55361
55362 /* This function will propagate the clientdata field of type to
55363 * any new swig_type_info structures that have been added into the list
55364 * of equivalent types. It is like calling
55365 * SWIG_TypeClientData(type, clientdata) a second time.
55366 */
55367 SWIGRUNTIME void
55368 SWIG_PropagateClientData(void) {
55369 size_t i;
55370 swig_cast_info *equiv;
55371 static int init_run = 0;
55372
55373 if (init_run) return;
55374 init_run = 1;
55375
55376 for (i = 0; i < swig_module.size; i++) {
55377 if (swig_module.types[i]->clientdata) {
55378 equiv = swig_module.types[i]->cast;
55379 while (equiv) {
55380 if (!equiv->converter) {
55381 if (equiv->type && !equiv->type->clientdata)
55382 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55383 }
55384 equiv = equiv->next;
55385 }
55386 }
55387 }
55388 }
55389
55390 #ifdef __cplusplus
55391 #if 0
55392 {
55393 /* c-mode */
55394 #endif
55395 }
55396 #endif
55397
55398
55399
55400 #ifdef __cplusplus
55401 extern "C" {
55402 #endif
55403
55404 /* Python-specific SWIG API */
55405 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55406 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55407 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55408
55409 /* -----------------------------------------------------------------------------
55410 * global variable support code.
55411 * ----------------------------------------------------------------------------- */
55412
55413 typedef struct swig_globalvar {
55414 char *name; /* Name of global variable */
55415 PyObject *(*get_attr)(void); /* Return the current value */
55416 int (*set_attr)(PyObject *); /* Set the value */
55417 struct swig_globalvar *next;
55418 } swig_globalvar;
55419
55420 typedef struct swig_varlinkobject {
55421 PyObject_HEAD
55422 swig_globalvar *vars;
55423 } swig_varlinkobject;
55424
55425 SWIGINTERN PyObject *
55426 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55427 return PyString_FromString("<Swig global variables>");
55428 }
55429
55430 SWIGINTERN PyObject *
55431 swig_varlink_str(swig_varlinkobject *v) {
55432 PyObject *str = PyString_FromString("(");
55433 swig_globalvar *var;
55434 for (var = v->vars; var; var=var->next) {
55435 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55436 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55437 }
55438 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55439 return str;
55440 }
55441
55442 SWIGINTERN int
55443 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55444 PyObject *str = swig_varlink_str(v);
55445 fprintf(fp,"Swig global variables ");
55446 fprintf(fp,"%s\n", PyString_AsString(str));
55447 Py_DECREF(str);
55448 return 0;
55449 }
55450
55451 SWIGINTERN void
55452 swig_varlink_dealloc(swig_varlinkobject *v) {
55453 swig_globalvar *var = v->vars;
55454 while (var) {
55455 swig_globalvar *n = var->next;
55456 free(var->name);
55457 free(var);
55458 var = n;
55459 }
55460 }
55461
55462 SWIGINTERN PyObject *
55463 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55464 PyObject *res = NULL;
55465 swig_globalvar *var = v->vars;
55466 while (var) {
55467 if (strcmp(var->name,n) == 0) {
55468 res = (*var->get_attr)();
55469 break;
55470 }
55471 var = var->next;
55472 }
55473 if (res == NULL && !PyErr_Occurred()) {
55474 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55475 }
55476 return res;
55477 }
55478
55479 SWIGINTERN int
55480 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55481 int res = 1;
55482 swig_globalvar *var = v->vars;
55483 while (var) {
55484 if (strcmp(var->name,n) == 0) {
55485 res = (*var->set_attr)(p);
55486 break;
55487 }
55488 var = var->next;
55489 }
55490 if (res == 1 && !PyErr_Occurred()) {
55491 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55492 }
55493 return res;
55494 }
55495
55496 SWIGINTERN PyTypeObject*
55497 swig_varlink_type(void) {
55498 static char varlink__doc__[] = "Swig var link object";
55499 static PyTypeObject varlink_type;
55500 static int type_init = 0;
55501 if (!type_init) {
55502 const PyTypeObject tmp
55503 = {
55504 PyObject_HEAD_INIT(NULL)
55505 0, /* Number of items in variable part (ob_size) */
55506 (char *)"swigvarlink", /* Type name (tp_name) */
55507 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55508 0, /* Itemsize (tp_itemsize) */
55509 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55510 (printfunc) swig_varlink_print, /* Print (tp_print) */
55511 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55512 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55513 0, /* tp_compare */
55514 (reprfunc) swig_varlink_repr, /* tp_repr */
55515 0, /* tp_as_number */
55516 0, /* tp_as_sequence */
55517 0, /* tp_as_mapping */
55518 0, /* tp_hash */
55519 0, /* tp_call */
55520 (reprfunc)swig_varlink_str, /* tp_str */
55521 0, /* tp_getattro */
55522 0, /* tp_setattro */
55523 0, /* tp_as_buffer */
55524 0, /* tp_flags */
55525 varlink__doc__, /* tp_doc */
55526 0, /* tp_traverse */
55527 0, /* tp_clear */
55528 0, /* tp_richcompare */
55529 0, /* tp_weaklistoffset */
55530 #if PY_VERSION_HEX >= 0x02020000
55531 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55532 #endif
55533 #if PY_VERSION_HEX >= 0x02030000
55534 0, /* tp_del */
55535 #endif
55536 #ifdef COUNT_ALLOCS
55537 0,0,0,0 /* tp_alloc -> tp_next */
55538 #endif
55539 };
55540 varlink_type = tmp;
55541 varlink_type.ob_type = &PyType_Type;
55542 type_init = 1;
55543 }
55544 return &varlink_type;
55545 }
55546
55547 /* Create a variable linking object for use later */
55548 SWIGINTERN PyObject *
55549 SWIG_Python_newvarlink(void) {
55550 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55551 if (result) {
55552 result->vars = 0;
55553 }
55554 return ((PyObject*) result);
55555 }
55556
55557 SWIGINTERN void
55558 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55559 swig_varlinkobject *v = (swig_varlinkobject *) p;
55560 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55561 if (gv) {
55562 size_t size = strlen(name)+1;
55563 gv->name = (char *)malloc(size);
55564 if (gv->name) {
55565 strncpy(gv->name,name,size);
55566 gv->get_attr = get_attr;
55567 gv->set_attr = set_attr;
55568 gv->next = v->vars;
55569 }
55570 }
55571 v->vars = gv;
55572 }
55573
55574 SWIGINTERN PyObject *
55575 SWIG_globals() {
55576 static PyObject *_SWIG_globals = 0;
55577 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55578 return _SWIG_globals;
55579 }
55580
55581 /* -----------------------------------------------------------------------------
55582 * constants/methods manipulation
55583 * ----------------------------------------------------------------------------- */
55584
55585 /* Install Constants */
55586 SWIGINTERN void
55587 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55588 PyObject *obj = 0;
55589 size_t i;
55590 for (i = 0; constants[i].type; ++i) {
55591 switch(constants[i].type) {
55592 case SWIG_PY_POINTER:
55593 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55594 break;
55595 case SWIG_PY_BINARY:
55596 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55597 break;
55598 default:
55599 obj = 0;
55600 break;
55601 }
55602 if (obj) {
55603 PyDict_SetItemString(d, constants[i].name, obj);
55604 Py_DECREF(obj);
55605 }
55606 }
55607 }
55608
55609 /* -----------------------------------------------------------------------------*/
55610 /* Fix SwigMethods to carry the callback ptrs when needed */
55611 /* -----------------------------------------------------------------------------*/
55612
55613 SWIGINTERN void
55614 SWIG_Python_FixMethods(PyMethodDef *methods,
55615 swig_const_info *const_table,
55616 swig_type_info **types,
55617 swig_type_info **types_initial) {
55618 size_t i;
55619 for (i = 0; methods[i].ml_name; ++i) {
55620 char *c = methods[i].ml_doc;
55621 if (c && (c = strstr(c, "swig_ptr: "))) {
55622 int j;
55623 swig_const_info *ci = 0;
55624 char *name = c + 10;
55625 for (j = 0; const_table[j].type; ++j) {
55626 if (strncmp(const_table[j].name, name,
55627 strlen(const_table[j].name)) == 0) {
55628 ci = &(const_table[j]);
55629 break;
55630 }
55631 }
55632 if (ci) {
55633 size_t shift = (ci->ptype) - types;
55634 swig_type_info *ty = types_initial[shift];
55635 size_t ldoc = (c - methods[i].ml_doc);
55636 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55637 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55638 if (ndoc) {
55639 char *buff = ndoc;
55640 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55641 if (ptr) {
55642 strncpy(buff, methods[i].ml_doc, ldoc);
55643 buff += ldoc;
55644 strncpy(buff, "swig_ptr: ", 10);
55645 buff += 10;
55646 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55647 methods[i].ml_doc = ndoc;
55648 }
55649 }
55650 }
55651 }
55652 }
55653 }
55654
55655 #ifdef __cplusplus
55656 }
55657 #endif
55658
55659 /* -----------------------------------------------------------------------------*
55660 * Partial Init method
55661 * -----------------------------------------------------------------------------*/
55662
55663 #ifdef __cplusplus
55664 extern "C"
55665 #endif
55666 SWIGEXPORT void SWIG_init(void) {
55667 PyObject *m, *d;
55668
55669 /* Fix SwigMethods to carry the callback ptrs when needed */
55670 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55671
55672 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55673 d = PyModule_GetDict(m);
55674
55675 SWIG_InitializeModule(0);
55676 SWIG_InstallConstants(d,swig_const_table);
55677
55678
55679
55680 #ifndef wxPyUSE_EXPORT
55681 // Make our API structure a CObject so other modules can import it
55682 // from this module.
55683 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55684 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55685 Py_XDECREF(cobj);
55686 #endif
55687
55688 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55689 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55690 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55691 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55692 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55693 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55694 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55695 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55696 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55697 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55698 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55699 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55700 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55701 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55702 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55703 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55704 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55705 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55706 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55707 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55708 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55709 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55710 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55711 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55712 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55713 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55714 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55715 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55716 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55717 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55718 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55719 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55720 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55721 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55722 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55723 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55724 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55725 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55726 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55727 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55728 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55729 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55730 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55731 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55732 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55733 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55734 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55735 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55736 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55737 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55738 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55739 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55740 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55741 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55742 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55743 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55744 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55745 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55746 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55747 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55748 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55749 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55750 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55751 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55752 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55753 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55754 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55755 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55756 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55757 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55758 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55759 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55760 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55761 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55762 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55763 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55764 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55765 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55766 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55767 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55768 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55769 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55770 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55771 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55772 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55773 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55774 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55775 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55776 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55777 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55778 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55779 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55780 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55781 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55782 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55783 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55784 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55785 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55786 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55787 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55788 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55789 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55790 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55791 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55792 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55793 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55794 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55795 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55796 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55797 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55798 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55799 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55800 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55801 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55802 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55803 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55804 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55805 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55806 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55807 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55808 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55809 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55810 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55811 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55812 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55813 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55814 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55815 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55816 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55817 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55818 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55819 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55820 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55821 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55822 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55823 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55824 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55825 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55826 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55827 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55828 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55829 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55830 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55831 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55832 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55833 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55834 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55835 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55836 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55837 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55838 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55839 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55840 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55841 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55842 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55843 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55844 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55845 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55846 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55847 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55848 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55849 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55850 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55851 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55852 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55853 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55854 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55855 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55856 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55857 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55858 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55859 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55860 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55861 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55862 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55863 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55864 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55865 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55866 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55867 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55868 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55869 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55870 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55871 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55872 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55873 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55874 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55875 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55876 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55877 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55878 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55879 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55880 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55881 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55882 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55883 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55884 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55885 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55886 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55887 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55888 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55889 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55890 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55891 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55892 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55893 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55894 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55895 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55896 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55897 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55898 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55899 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55900 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55901 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55902 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55903 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55904 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55905 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55906 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55907 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55908 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55909 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55910 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55911 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55912 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55913 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55914 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55915 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55916 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55917 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55918 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55919 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55920 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55921 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55922 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55923 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55924 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55925 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55926 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55927 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55928 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55929 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55930 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55931 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55932 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55933 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55934 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55935 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55936 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55937 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55938 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55939 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55940 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55941 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55942 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55943 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55944 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55945 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55946 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55947 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55948 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55949 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55950 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55951 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55952 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55953 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55954 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55955 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55956 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55957 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55958 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55959 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55960 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55961 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55962 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55963 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55964 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55965 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55966 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55967 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55968 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55969 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55970 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55971 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55972 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55973 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55974 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55975 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55976 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55977 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55978 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55979 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55980 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55981 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55982 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55983 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55984 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55985 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55986 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55987 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55988 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55989 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55990 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55991 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55992 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55993 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55994 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55995 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55996 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55997 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55998 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55999 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56000 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56001 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56002 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56003 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56004 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56005 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56006 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56007 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56008 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56009 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56010 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56011 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56012 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56013 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56014 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56015 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56016 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56017 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56018 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56019 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56020 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56021 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56022 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56023 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56024 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56025 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56026 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56027 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56028 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56029 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56030 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56031 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56032 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56033 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56034 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56035 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56036 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56037 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56038 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56039 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56040 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56041 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56042 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56043 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56044 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56045 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56046 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56047 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56048 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56049 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56050 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56051 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56052 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56053 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56054 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56055 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56056 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56057 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56058 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56059 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56060 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56061 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56062 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56063 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56064 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56065 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56066 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56067 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56068 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56069 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56070 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56071 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56072 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56073 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56074 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56075 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56076 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56077 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56078 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56079 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56080 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56081 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56082 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56083 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56084 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56085 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56086 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56087 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56088 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56089 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56090 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56091 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56092 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56093 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56094 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56095 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56096 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56097 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56098 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56099 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56100 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56101 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56102 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56103 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56104 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56105 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56106 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56107 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56108 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56109 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56110 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56111 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56112 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56113 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56114 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56115 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56116 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56117 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56118 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56119 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56120 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56121 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56122 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56123 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56124 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56125 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56126 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56127 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56128 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56129 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56130 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56131 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56132 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56133 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56134 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56135 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56136 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56137 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56138 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56139 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56140 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56141 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56142 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56143 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56144 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56145 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56146 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56147 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56148 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56149 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56150 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56151 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56152 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56153 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56154 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56155 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56156 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56157 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56158 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56159 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56160 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56161 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56162 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56163 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56164 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56165 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56166 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56167 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56168 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56169 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56170 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56171 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56172 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56173 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56174 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56175 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56176 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56177 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56178 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56179 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56180 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56181 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56182 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56183 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56184 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56185 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56186 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56187 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56188 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56189 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56190 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56191 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56192 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56193 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56194 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56195 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56196 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56197 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56198 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56199 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56200 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56201 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56202 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56203 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56204 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56205 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56206 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56207 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56208 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56209 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56210 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56211 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56212 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56213 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56214 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56215 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56216 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56217 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56218 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56219 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56220 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56221 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56222 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56223 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56224 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56225 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56226 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56227 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56228 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56229 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56230 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56231 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56232 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56233 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56234 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56235 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56236 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56237 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56238 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56239 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56240 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56241 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56242 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56243 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56244 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56245 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56246 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56247 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56248 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56249 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56250 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56251 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56252 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56253 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56254 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56255 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56256 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56257 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56258 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56259 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56260 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56261 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56262 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56263 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56264 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56265 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56266 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56267 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56268 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56269 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56270 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56271 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56272 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56273 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56274 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56275 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56276 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56277 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56278 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56279 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56280 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56281 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56282 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56283 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56284 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56285 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56286 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56287 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56288 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56289 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56290 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56291 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56292 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56293 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56294 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56295 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56296 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56297 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56298 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56299 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56300 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56301 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56302 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56303 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56304 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56305 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56306 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56307 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56308 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56309 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56310 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56311 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56312 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56313 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56314 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56315 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56316 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56317 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56318 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56319 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56320 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56321 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56322 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56323 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56324 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56325 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56326 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56327 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56328 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56329 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56330 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56331 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56332 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56333 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56334 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56335 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56336 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56337 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56338 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56339 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56340 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56341 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56342 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56343 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56344 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56345 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56346 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56347 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56348 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56349 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56350 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56351
56352 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56353
56354
56355 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56356
56357 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56358 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56359 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56360 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56361 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56362 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56363 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56364 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56365 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56366 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56367 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56368 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56369 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56370 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56371 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56372 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56373 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56374 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56375 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56376 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56377 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56378 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56379 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56380 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56381 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56382 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56383 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56384 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56385 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56386 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56387 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56388 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56389 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56390 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56391 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56392 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56393 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56394 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56395 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56396 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56397 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56398 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56399 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56400 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56401 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56402 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56403 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56404 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56405 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56406 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56407 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56408 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56409 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56410 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56411 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56412 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56413 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56414 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56415 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56416 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56417 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56418 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56419 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56420 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56421 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56422 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56423 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56424 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56425 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56426 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56427 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56428 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56429 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56430 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56431 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56432 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56433 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56434 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56435 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56436 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56437 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56438 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56439 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56440 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56441 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56442 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56443 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56444 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56445 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56446 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56447 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56448 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56449 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56450 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56451 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56452 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56453 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56454 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56455 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56456 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56457 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56458 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56459 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56460 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56461 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56462 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56463 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56464 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56465 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56466 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56467 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56468 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56469 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56470 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56471 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56472 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56473 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56474 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56475 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56476 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56477 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56478 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56479 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56480 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56481 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56482 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56483 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56484 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56485 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56486 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56487 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56488 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56489 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56490 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56491 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56492 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56493 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56494 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56495 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56496 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56497 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56498 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56499 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56500 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56501 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56502 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56503 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56504 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56505 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56506 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56507 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56508 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56509 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56510 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56511 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56512 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56513 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56514 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56515 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56516 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56517 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56518 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56519 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56520 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56521 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56522 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56523 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56524 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56525 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56526 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56527 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56528 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56529 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56530 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56531 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56532 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56533 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56534 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56535 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56536 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56537 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56538 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56539 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56540 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56541 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56542 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56543 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56544 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56545 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56546 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56547 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56548 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56549 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56550 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56551 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56552 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56553 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56554 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56555 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56556 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56557 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56558 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56559 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56560 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56561 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56562 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56563
56564 // Initialize threading, some globals and such
56565 __wxPyPreStart(d);
56566
56567
56568 // Although these are defined in __version__ they need to be here too so
56569 // that an assert can be done to ensure that the wxPython and the wxWindows
56570 // versions match.
56571 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56572 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56573 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56574
56575 }
56576
wxWidgets (Impactor)