]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added missing platform constants
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* 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
3750 void wxApp_CleanUp() {
3751 __wxPyCleanup();
3752 }
3753
3754
3755 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3756
3757
3758
3759
3760
3761 SWIGINTERNINLINE PyObject *
3762 SWIG_FromCharPtr(const char *cptr)
3763 {
3764 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3765 }
3766
3767
3768 #if 0 // #ifdef __WXMAC__
3769
3770 // A dummy class that raises an exception if used...
3771 class wxEventLoop
3772 {
3773 public:
3774 wxEventLoop() { wxPyRaiseNotImplemented(); }
3775 int Run() { return 0; }
3776 void Exit(int rc = 0) {}
3777 bool Pending() const { return false; }
3778 bool Dispatch() { return false; }
3779 bool IsRunning() const { return false; }
3780 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3781 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3782 };
3783
3784 #else
3785
3786 #include <wx/evtloop.h>
3787
3788 #endif
3789
3790
3791
3792 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3793 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3794 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3795 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3796 wxWindowList& list = self->GetChildren();
3797 return wxPy_ConvertList(&list);
3798 }
3799 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
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
3821 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3822 return wxWindow::FindWindowById(id, parent);
3823 }
3824
3825 wxWindow* wxFindWindowByName( const wxString& name,
3826 const wxWindow *parent = NULL ) {
3827 return wxWindow::FindWindowByName(name, parent);
3828 }
3829
3830 wxWindow* wxFindWindowByLabel( const wxString& label,
3831 const wxWindow *parent = NULL ) {
3832 return wxWindow::FindWindowByLabel(label, parent);
3833 }
3834
3835
3836 #ifdef __WXMSW__
3837 #include <wx/msw/private.h> // to get wxGetWindowId
3838 #endif
3839
3840
3841 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3842 #ifdef __WXMSW__
3843 WXHWND hWnd = (WXHWND)_hWnd;
3844 long id = wxGetWindowId(hWnd);
3845 wxWindow* win = new wxWindow;
3846 if (parent)
3847 parent->AddChild(win);
3848 win->SetEventHandler(win);
3849 win->SetHWND(hWnd);
3850 win->SetId(id);
3851 win->SubclassWin(hWnd);
3852 win->AdoptAttributesFromHWND();
3853 win->SetupColours();
3854 return win;
3855 #else
3856 wxPyRaiseNotImplemented();
3857 return NULL;
3858 #endif
3859 }
3860
3861
3862 PyObject* GetTopLevelWindows() {
3863 return wxPy_ConvertList(&wxTopLevelWindows);
3864 }
3865
3866
3867 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3868 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3869 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3870
3871 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3872
3873
3874 SWIGINTERNINLINE int
3875 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3876 {
3877 unsigned long v;
3878 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3879 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3880 return res;
3881 }
3882
3883 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3884 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3885 wxMenuItemList& list = self->GetMenuItems();
3886 return wxPy_ConvertList(&list);
3887 }
3888 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3889 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3890 static const wxString wxPyControlNameStr(wxControlNameStr);
3891 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3892 if (clientData) {
3893 wxPyClientData* data = new wxPyClientData(clientData);
3894 return self->Append(item, data);
3895 } else
3896 return self->Append(item);
3897 }
3898 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3899 if (clientData) {
3900 wxPyClientData* data = new wxPyClientData(clientData);
3901 return self->Insert(item, pos, data);
3902 } else
3903 return self->Insert(item, pos);
3904 }
3905 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3906 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3907 if (data) {
3908 Py_INCREF(data->m_obj);
3909 return data->m_obj;
3910 } else {
3911 Py_INCREF(Py_None);
3912 return Py_None;
3913 }
3914 }
3915 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3916 wxPyClientData* data = new wxPyClientData(clientData);
3917 self->SetClientObject(n, data);
3918 }
3919
3920
3921 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3922 wxPyUserData* data = NULL;
3923 if ( userData ) {
3924 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3925 data = new wxPyUserData(userData);
3926 wxPyEndBlockThreads(blocked);
3927 }
3928 return new wxSizerItem(window, proportion, flag, border, data);
3929 }
3930 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3931 wxPyUserData* data = NULL;
3932 if ( userData ) {
3933 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3934 data = new wxPyUserData(userData);
3935 wxPyEndBlockThreads(blocked);
3936 }
3937 return new wxSizerItem(width, height, proportion, flag, border, data);
3938 }
3939 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3940 wxPyUserData* data = NULL;
3941 if ( userData ) {
3942 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3943 data = new wxPyUserData(userData);
3944 wxPyEndBlockThreads(blocked);
3945 }
3946 return new wxSizerItem(sizer, proportion, flag, border, data);
3947 }
3948
3949 #include <float.h>
3950
3951
3952 SWIGINTERN int
3953 SWIG_AsVal_float (PyObject * obj, float *val)
3954 {
3955 double v;
3956 int res = SWIG_AsVal_double (obj, &v);
3957 if (SWIG_IsOK(res)) {
3958 if ((v < -FLT_MAX || v > FLT_MAX)) {
3959 return SWIG_OverflowError;
3960 } else {
3961 if (val) *val = static_cast< float >(v);
3962 }
3963 }
3964 return res;
3965 }
3966
3967
3968 SWIGINTERNINLINE PyObject *
3969 SWIG_From_float (float value)
3970 {
3971 return SWIG_From_double (value);
3972 }
3973
3974 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3975 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3976 if (data) {
3977 Py_INCREF(data->m_obj);
3978 return data->m_obj;
3979 } else {
3980 Py_INCREF(Py_None);
3981 return Py_None;
3982 }
3983 }
3984 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3985 wxPyUserData* data = NULL;
3986 if ( userData ) {
3987 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3988 data = new wxPyUserData(userData);
3989 wxPyEndBlockThreads(blocked);
3990 }
3991 self->SetUserData(data);
3992 }
3993
3994 // Figure out the type of the sizer item
3995
3996 struct wxPySizerItemInfo {
3997 wxPySizerItemInfo()
3998 : window(NULL), sizer(NULL), gotSize(false),
3999 size(wxDefaultSize), gotPos(false), pos(-1)
4000 {}
4001
4002 wxWindow* window;
4003 wxSizer* sizer;
4004 bool gotSize;
4005 wxSize size;
4006 bool gotPos;
4007 int pos;
4008 };
4009
4010 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4011
4012 wxPySizerItemInfo info;
4013 wxSize size;
4014 wxSize* sizePtr = &size;
4015
4016 // Find out what the type of the item is
4017 // try wxWindow
4018 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4019 PyErr_Clear();
4020 info.window = NULL;
4021
4022 // try wxSizer
4023 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4024 PyErr_Clear();
4025 info.sizer = NULL;
4026
4027 // try wxSize or (w,h)
4028 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4029 info.size = *sizePtr;
4030 info.gotSize = true;
4031 }
4032
4033 // or a single int
4034 if (checkIdx && PyInt_Check(item)) {
4035 info.pos = PyInt_AsLong(item);
4036 info.gotPos = true;
4037 }
4038 }
4039 }
4040
4041 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4042 // no expected type, figure out what kind of error message to generate
4043 if ( !checkSize && !checkIdx )
4044 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4045 else if ( checkSize && !checkIdx )
4046 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4047 else if ( !checkSize && checkIdx)
4048 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4049 else
4050 // can this one happen?
4051 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4052 }
4053
4054 return info;
4055 }
4056
4057 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4058 if (!self->GetClientObject())
4059 self->SetClientObject(new wxPyOORClientData(_self));
4060 }
4061 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4062
4063 wxPyUserData* data = NULL;
4064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4065 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4066 if ( userData && (info.window || info.sizer || info.gotSize) )
4067 data = new wxPyUserData(userData);
4068 if ( info.sizer )
4069 PyObject_SetAttrString(item,"thisown",Py_False);
4070 wxPyEndBlockThreads(blocked);
4071
4072 // Now call the real Add method if a valid item type was found
4073 if ( info.window )
4074 return self->Add(info.window, proportion, flag, border, data);
4075 else if ( info.sizer )
4076 return self->Add(info.sizer, proportion, flag, border, data);
4077 else if (info.gotSize)
4078 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4079 proportion, flag, border, data);
4080 else
4081 return NULL;
4082 }
4083 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4084
4085 wxPyUserData* data = NULL;
4086 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4087 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4088 if ( userData && (info.window || info.sizer || info.gotSize) )
4089 data = new wxPyUserData(userData);
4090 if ( info.sizer )
4091 PyObject_SetAttrString(item,"thisown",Py_False);
4092 wxPyEndBlockThreads(blocked);
4093
4094 // Now call the real Insert method if a valid item type was found
4095 if ( info.window )
4096 return self->Insert(before, info.window, proportion, flag, border, data);
4097 else if ( info.sizer )
4098 return self->Insert(before, info.sizer, proportion, flag, border, data);
4099 else if (info.gotSize)
4100 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4101 proportion, flag, border, data);
4102 else
4103 return NULL;
4104 }
4105 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4106
4107 wxPyUserData* data = NULL;
4108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4109 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4110 if ( userData && (info.window || info.sizer || info.gotSize) )
4111 data = new wxPyUserData(userData);
4112 if ( info.sizer )
4113 PyObject_SetAttrString(item,"thisown",Py_False);
4114 wxPyEndBlockThreads(blocked);
4115
4116 // Now call the real Prepend method if a valid item type was found
4117 if ( info.window )
4118 return self->Prepend(info.window, proportion, flag, border, data);
4119 else if ( info.sizer )
4120 return self->Prepend(info.sizer, proportion, flag, border, data);
4121 else if (info.gotSize)
4122 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4123 proportion, flag, border, data);
4124 else
4125 return NULL;
4126 }
4127 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4130 wxPyEndBlockThreads(blocked);
4131 if ( info.window )
4132 return self->Remove(info.window);
4133 else if ( info.sizer )
4134 return self->Remove(info.sizer);
4135 else if ( info.gotPos )
4136 return self->Remove(info.pos);
4137 else
4138 return false;
4139 }
4140 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4142 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4143 wxPyEndBlockThreads(blocked);
4144 if ( info.window )
4145 return self->Detach(info.window);
4146 else if ( info.sizer )
4147 return self->Detach(info.sizer);
4148 else if ( info.gotPos )
4149 return self->Detach(info.pos);
4150 else
4151 return false;
4152 }
4153 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4156 wxPyEndBlockThreads(blocked);
4157 if ( info.window )
4158 return self->GetItem(info.window);
4159 else if ( info.sizer )
4160 return self->GetItem(info.sizer);
4161 else if ( info.gotPos )
4162 return self->GetItem(info.pos);
4163 else
4164 return NULL;
4165 }
4166 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4168 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4169 wxPyEndBlockThreads(blocked);
4170 if ( info.window )
4171 self->SetItemMinSize(info.window, size);
4172 else if ( info.sizer )
4173 self->SetItemMinSize(info.sizer, size);
4174 else if ( info.gotPos )
4175 self->SetItemMinSize(info.pos, size);
4176 }
4177 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4178 wxSizerItemList& list = self->GetChildren();
4179 return wxPy_ConvertList(&list);
4180 }
4181 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4184 wxPyEndBlockThreads(blocked);
4185 if ( info.window )
4186 return self->Show(info.window, show, recursive);
4187 else if ( info.sizer )
4188 return self->Show(info.sizer, show, recursive);
4189 else if ( info.gotPos )
4190 return self->Show(info.pos, show);
4191 else
4192 return false;
4193 }
4194 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4196 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4197 wxPyEndBlockThreads(blocked);
4198 if ( info.window )
4199 return self->IsShown(info.window);
4200 else if ( info.sizer )
4201 return self->IsShown(info.sizer);
4202 else if ( info.gotPos )
4203 return self->IsShown(info.pos);
4204 else
4205 return false;
4206 }
4207
4208 // See pyclasses.h
4209 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4210 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4211 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4212
4213
4214
4215
4216 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4217 {
4218 if (source == Py_None) {
4219 **obj = wxGBPosition(-1,-1);
4220 return true;
4221 }
4222 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4223 }
4224
4225 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4226 {
4227 if (source == Py_None) {
4228 **obj = wxGBSpan(-1,-1);
4229 return true;
4230 }
4231 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4232 }
4233
4234
4235 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4236 wxGBPosition temp, *obj = &temp;
4237 if ( other == Py_None ) return false;
4238 if ( ! wxGBPosition_helper(other, &obj) ) {
4239 PyErr_Clear();
4240 return false;
4241 }
4242 return self->operator==(*obj);
4243 }
4244 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4245 wxGBPosition temp, *obj = &temp;
4246 if ( other == Py_None ) return true;
4247 if ( ! wxGBPosition_helper(other, &obj)) {
4248 PyErr_Clear();
4249 return true;
4250 }
4251 return self->operator!=(*obj);
4252 }
4253 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4254 self->SetRow(row);
4255 self->SetCol(col);
4256 }
4257 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4258 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4259 PyObject* tup = PyTuple_New(2);
4260 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4261 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4262 wxPyEndBlockThreads(blocked);
4263 return tup;
4264 }
4265 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4266 wxGBSpan temp, *obj = &temp;
4267 if ( other == Py_None ) return false;
4268 if ( ! wxGBSpan_helper(other, &obj) ) {
4269 PyErr_Clear();
4270 return false;
4271 }
4272 return self->operator==(*obj);
4273 }
4274 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4275 wxGBSpan temp, *obj = &temp;
4276 if ( other == Py_None ) return true;
4277 if ( ! wxGBSpan_helper(other, &obj)) {
4278 PyErr_Clear();
4279 return true;
4280 }
4281 return self->operator!=(*obj);
4282 }
4283 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4284 self->SetRowspan(rowspan);
4285 self->SetColspan(colspan);
4286 }
4287 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4288 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4289 PyObject* tup = PyTuple_New(2);
4290 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4291 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4292 wxPyEndBlockThreads(blocked);
4293 return tup;
4294 }
4295 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4296 wxPyUserData* data = NULL;
4297 if ( userData ) {
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 data = new wxPyUserData(userData);
4300 wxPyEndBlockThreads(blocked);
4301 }
4302 return new wxGBSizerItem(window, pos, span, flag, border, data);
4303 }
4304 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4305 wxPyUserData* data = NULL;
4306 if ( userData ) {
4307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4308 data = new wxPyUserData(userData);
4309 wxPyEndBlockThreads(blocked);
4310 }
4311 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4312 }
4313 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4314 wxPyUserData* data = NULL;
4315 if ( userData ) {
4316 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4317 data = new wxPyUserData(userData);
4318 wxPyEndBlockThreads(blocked);
4319 }
4320 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4321 }
4322 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4323 int row, col;
4324 self->GetEndPos(row, col);
4325 return wxGBPosition(row, col);
4326 }
4327 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4328
4329 wxPyUserData* data = NULL;
4330 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4331 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4332 if ( userData && (info.window || info.sizer || info.gotSize) )
4333 data = new wxPyUserData(userData);
4334 if ( info.sizer )
4335 PyObject_SetAttrString(item,"thisown",Py_False);
4336 wxPyEndBlockThreads(blocked);
4337
4338 // Now call the real Add method if a valid item type was found
4339 if ( info.window )
4340 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4341 else if ( info.sizer )
4342 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4343 else if (info.gotSize)
4344 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4345 pos, span, flag, border, data);
4346 return NULL;
4347 }
4348
4349
4350 #ifdef __cplusplus
4351 extern "C" {
4352 #endif
4353 SWIGINTERN int EmptyString_set(PyObject *) {
4354 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4355 return 1;
4356 }
4357
4358
4359 SWIGINTERN PyObject *EmptyString_get(void) {
4360 PyObject *pyobj = 0;
4361
4362 {
4363 #if wxUSE_UNICODE
4364 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4365 #else
4366 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4367 #endif
4368 }
4369 return pyobj;
4370 }
4371
4372
4373 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4374 PyObject *resultobj = 0;
4375 wxObject *arg1 = (wxObject *) 0 ;
4376 wxString result;
4377 void *argp1 = 0 ;
4378 int res1 = 0 ;
4379 PyObject *swig_obj[1] ;
4380
4381 if (!args) SWIG_fail;
4382 swig_obj[0] = args;
4383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4384 if (!SWIG_IsOK(res1)) {
4385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4386 }
4387 arg1 = reinterpret_cast< wxObject * >(argp1);
4388 {
4389 PyThreadState* __tstate = wxPyBeginAllowThreads();
4390 result = wxObject_GetClassName(arg1);
4391 wxPyEndAllowThreads(__tstate);
4392 if (PyErr_Occurred()) SWIG_fail;
4393 }
4394 {
4395 #if wxUSE_UNICODE
4396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4397 #else
4398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4399 #endif
4400 }
4401 return resultobj;
4402 fail:
4403 return NULL;
4404 }
4405
4406
4407 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4408 PyObject *resultobj = 0;
4409 wxObject *arg1 = (wxObject *) 0 ;
4410 void *argp1 = 0 ;
4411 int res1 = 0 ;
4412 PyObject *swig_obj[1] ;
4413
4414 if (!args) SWIG_fail;
4415 swig_obj[0] = args;
4416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4417 if (!SWIG_IsOK(res1)) {
4418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4419 }
4420 arg1 = reinterpret_cast< wxObject * >(argp1);
4421 {
4422 PyThreadState* __tstate = wxPyBeginAllowThreads();
4423 wxObject_Destroy(arg1);
4424 wxPyEndAllowThreads(__tstate);
4425 if (PyErr_Occurred()) SWIG_fail;
4426 }
4427 resultobj = SWIG_Py_Void();
4428 return resultobj;
4429 fail:
4430 return NULL;
4431 }
4432
4433
4434 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4435 PyObject *obj;
4436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4437 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4438 return SWIG_Py_Void();
4439 }
4440
4441 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4442 PyObject *resultobj = 0;
4443 wxSize *arg1 = (wxSize *) 0 ;
4444 int arg2 ;
4445 void *argp1 = 0 ;
4446 int res1 = 0 ;
4447 int val2 ;
4448 int ecode2 = 0 ;
4449 PyObject *swig_obj[2] ;
4450
4451 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4453 if (!SWIG_IsOK(res1)) {
4454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4455 }
4456 arg1 = reinterpret_cast< wxSize * >(argp1);
4457 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4458 if (!SWIG_IsOK(ecode2)) {
4459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4460 }
4461 arg2 = static_cast< int >(val2);
4462 if (arg1) (arg1)->x = arg2;
4463
4464 resultobj = SWIG_Py_Void();
4465 return resultobj;
4466 fail:
4467 return NULL;
4468 }
4469
4470
4471 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4472 PyObject *resultobj = 0;
4473 wxSize *arg1 = (wxSize *) 0 ;
4474 int result;
4475 void *argp1 = 0 ;
4476 int res1 = 0 ;
4477 PyObject *swig_obj[1] ;
4478
4479 if (!args) SWIG_fail;
4480 swig_obj[0] = args;
4481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4482 if (!SWIG_IsOK(res1)) {
4483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4484 }
4485 arg1 = reinterpret_cast< wxSize * >(argp1);
4486 result = (int) ((arg1)->x);
4487 resultobj = SWIG_From_int(static_cast< int >(result));
4488 return resultobj;
4489 fail:
4490 return NULL;
4491 }
4492
4493
4494 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4495 PyObject *resultobj = 0;
4496 wxSize *arg1 = (wxSize *) 0 ;
4497 int arg2 ;
4498 void *argp1 = 0 ;
4499 int res1 = 0 ;
4500 int val2 ;
4501 int ecode2 = 0 ;
4502 PyObject *swig_obj[2] ;
4503
4504 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4508 }
4509 arg1 = reinterpret_cast< wxSize * >(argp1);
4510 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4511 if (!SWIG_IsOK(ecode2)) {
4512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4513 }
4514 arg2 = static_cast< int >(val2);
4515 if (arg1) (arg1)->y = arg2;
4516
4517 resultobj = SWIG_Py_Void();
4518 return resultobj;
4519 fail:
4520 return NULL;
4521 }
4522
4523
4524 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4525 PyObject *resultobj = 0;
4526 wxSize *arg1 = (wxSize *) 0 ;
4527 int result;
4528 void *argp1 = 0 ;
4529 int res1 = 0 ;
4530 PyObject *swig_obj[1] ;
4531
4532 if (!args) SWIG_fail;
4533 swig_obj[0] = args;
4534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4535 if (!SWIG_IsOK(res1)) {
4536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4537 }
4538 arg1 = reinterpret_cast< wxSize * >(argp1);
4539 result = (int) ((arg1)->y);
4540 resultobj = SWIG_From_int(static_cast< int >(result));
4541 return resultobj;
4542 fail:
4543 return NULL;
4544 }
4545
4546
4547 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4548 PyObject *resultobj = 0;
4549 int arg1 = (int) 0 ;
4550 int arg2 = (int) 0 ;
4551 wxSize *result = 0 ;
4552 int val1 ;
4553 int ecode1 = 0 ;
4554 int val2 ;
4555 int ecode2 = 0 ;
4556 PyObject * obj0 = 0 ;
4557 PyObject * obj1 = 0 ;
4558 char * kwnames[] = {
4559 (char *) "w",(char *) "h", NULL
4560 };
4561
4562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4563 if (obj0) {
4564 ecode1 = SWIG_AsVal_int(obj0, &val1);
4565 if (!SWIG_IsOK(ecode1)) {
4566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4567 }
4568 arg1 = static_cast< int >(val1);
4569 }
4570 if (obj1) {
4571 ecode2 = SWIG_AsVal_int(obj1, &val2);
4572 if (!SWIG_IsOK(ecode2)) {
4573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4574 }
4575 arg2 = static_cast< int >(val2);
4576 }
4577 {
4578 PyThreadState* __tstate = wxPyBeginAllowThreads();
4579 result = (wxSize *)new wxSize(arg1,arg2);
4580 wxPyEndAllowThreads(__tstate);
4581 if (PyErr_Occurred()) SWIG_fail;
4582 }
4583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4584 return resultobj;
4585 fail:
4586 return NULL;
4587 }
4588
4589
4590 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4591 PyObject *resultobj = 0;
4592 wxSize *arg1 = (wxSize *) 0 ;
4593 void *argp1 = 0 ;
4594 int res1 = 0 ;
4595 PyObject *swig_obj[1] ;
4596
4597 if (!args) SWIG_fail;
4598 swig_obj[0] = args;
4599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4600 if (!SWIG_IsOK(res1)) {
4601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4602 }
4603 arg1 = reinterpret_cast< wxSize * >(argp1);
4604 {
4605 PyThreadState* __tstate = wxPyBeginAllowThreads();
4606 delete arg1;
4607
4608 wxPyEndAllowThreads(__tstate);
4609 if (PyErr_Occurred()) SWIG_fail;
4610 }
4611 resultobj = SWIG_Py_Void();
4612 return resultobj;
4613 fail:
4614 return NULL;
4615 }
4616
4617
4618 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4619 PyObject *resultobj = 0;
4620 wxSize *arg1 = (wxSize *) 0 ;
4621 PyObject *arg2 = (PyObject *) 0 ;
4622 bool result;
4623 void *argp1 = 0 ;
4624 int res1 = 0 ;
4625 PyObject * obj0 = 0 ;
4626 PyObject * obj1 = 0 ;
4627 char * kwnames[] = {
4628 (char *) "self",(char *) "other", NULL
4629 };
4630
4631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4633 if (!SWIG_IsOK(res1)) {
4634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4635 }
4636 arg1 = reinterpret_cast< wxSize * >(argp1);
4637 arg2 = obj1;
4638 {
4639 result = (bool)wxSize___eq__(arg1,arg2);
4640 if (PyErr_Occurred()) SWIG_fail;
4641 }
4642 {
4643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4644 }
4645 return resultobj;
4646 fail:
4647 return NULL;
4648 }
4649
4650
4651 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4652 PyObject *resultobj = 0;
4653 wxSize *arg1 = (wxSize *) 0 ;
4654 PyObject *arg2 = (PyObject *) 0 ;
4655 bool result;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 PyObject * obj0 = 0 ;
4659 PyObject * obj1 = 0 ;
4660 char * kwnames[] = {
4661 (char *) "self",(char *) "other", NULL
4662 };
4663
4664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4666 if (!SWIG_IsOK(res1)) {
4667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4668 }
4669 arg1 = reinterpret_cast< wxSize * >(argp1);
4670 arg2 = obj1;
4671 {
4672 result = (bool)wxSize___ne__(arg1,arg2);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 {
4676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4677 }
4678 return resultobj;
4679 fail:
4680 return NULL;
4681 }
4682
4683
4684 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4685 PyObject *resultobj = 0;
4686 wxSize *arg1 = (wxSize *) 0 ;
4687 wxSize *arg2 = 0 ;
4688 wxSize result;
4689 void *argp1 = 0 ;
4690 int res1 = 0 ;
4691 wxSize temp2 ;
4692 PyObject * obj0 = 0 ;
4693 PyObject * obj1 = 0 ;
4694 char * kwnames[] = {
4695 (char *) "self",(char *) "sz", NULL
4696 };
4697
4698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4700 if (!SWIG_IsOK(res1)) {
4701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4702 }
4703 arg1 = reinterpret_cast< wxSize * >(argp1);
4704 {
4705 arg2 = &temp2;
4706 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4707 }
4708 {
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 result = (arg1)->operator +((wxSize const &)*arg2);
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4722 PyObject *resultobj = 0;
4723 wxSize *arg1 = (wxSize *) 0 ;
4724 wxSize *arg2 = 0 ;
4725 wxSize result;
4726 void *argp1 = 0 ;
4727 int res1 = 0 ;
4728 wxSize temp2 ;
4729 PyObject * obj0 = 0 ;
4730 PyObject * obj1 = 0 ;
4731 char * kwnames[] = {
4732 (char *) "self",(char *) "sz", NULL
4733 };
4734
4735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4737 if (!SWIG_IsOK(res1)) {
4738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4739 }
4740 arg1 = reinterpret_cast< wxSize * >(argp1);
4741 {
4742 arg2 = &temp2;
4743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4744 }
4745 {
4746 PyThreadState* __tstate = wxPyBeginAllowThreads();
4747 result = (arg1)->operator -((wxSize const &)*arg2);
4748 wxPyEndAllowThreads(__tstate);
4749 if (PyErr_Occurred()) SWIG_fail;
4750 }
4751 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4752 return resultobj;
4753 fail:
4754 return NULL;
4755 }
4756
4757
4758 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4759 PyObject *resultobj = 0;
4760 wxSize *arg1 = (wxSize *) 0 ;
4761 wxSize *arg2 = 0 ;
4762 void *argp1 = 0 ;
4763 int res1 = 0 ;
4764 wxSize temp2 ;
4765 PyObject * obj0 = 0 ;
4766 PyObject * obj1 = 0 ;
4767 char * kwnames[] = {
4768 (char *) "self",(char *) "sz", NULL
4769 };
4770
4771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4773 if (!SWIG_IsOK(res1)) {
4774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4775 }
4776 arg1 = reinterpret_cast< wxSize * >(argp1);
4777 {
4778 arg2 = &temp2;
4779 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4780 }
4781 {
4782 PyThreadState* __tstate = wxPyBeginAllowThreads();
4783 (arg1)->IncTo((wxSize const &)*arg2);
4784 wxPyEndAllowThreads(__tstate);
4785 if (PyErr_Occurred()) SWIG_fail;
4786 }
4787 resultobj = SWIG_Py_Void();
4788 return resultobj;
4789 fail:
4790 return NULL;
4791 }
4792
4793
4794 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4795 PyObject *resultobj = 0;
4796 wxSize *arg1 = (wxSize *) 0 ;
4797 wxSize *arg2 = 0 ;
4798 void *argp1 = 0 ;
4799 int res1 = 0 ;
4800 wxSize temp2 ;
4801 PyObject * obj0 = 0 ;
4802 PyObject * obj1 = 0 ;
4803 char * kwnames[] = {
4804 (char *) "self",(char *) "sz", NULL
4805 };
4806
4807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4809 if (!SWIG_IsOK(res1)) {
4810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4811 }
4812 arg1 = reinterpret_cast< wxSize * >(argp1);
4813 {
4814 arg2 = &temp2;
4815 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4816 }
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 (arg1)->DecTo((wxSize const &)*arg2);
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 resultobj = SWIG_Py_Void();
4824 return resultobj;
4825 fail:
4826 return NULL;
4827 }
4828
4829
4830 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj = 0;
4832 wxSize *arg1 = (wxSize *) 0 ;
4833 int arg2 ;
4834 int arg3 ;
4835 void *argp1 = 0 ;
4836 int res1 = 0 ;
4837 int val2 ;
4838 int ecode2 = 0 ;
4839 int val3 ;
4840 int ecode3 = 0 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 PyObject * obj2 = 0 ;
4844 char * kwnames[] = {
4845 (char *) "self",(char *) "w",(char *) "h", NULL
4846 };
4847
4848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4850 if (!SWIG_IsOK(res1)) {
4851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4852 }
4853 arg1 = reinterpret_cast< wxSize * >(argp1);
4854 ecode2 = SWIG_AsVal_int(obj1, &val2);
4855 if (!SWIG_IsOK(ecode2)) {
4856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4857 }
4858 arg2 = static_cast< int >(val2);
4859 ecode3 = SWIG_AsVal_int(obj2, &val3);
4860 if (!SWIG_IsOK(ecode3)) {
4861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4862 }
4863 arg3 = static_cast< int >(val3);
4864 {
4865 PyThreadState* __tstate = wxPyBeginAllowThreads();
4866 (arg1)->Set(arg2,arg3);
4867 wxPyEndAllowThreads(__tstate);
4868 if (PyErr_Occurred()) SWIG_fail;
4869 }
4870 resultobj = SWIG_Py_Void();
4871 return resultobj;
4872 fail:
4873 return NULL;
4874 }
4875
4876
4877 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4878 PyObject *resultobj = 0;
4879 wxSize *arg1 = (wxSize *) 0 ;
4880 int arg2 ;
4881 void *argp1 = 0 ;
4882 int res1 = 0 ;
4883 int val2 ;
4884 int ecode2 = 0 ;
4885 PyObject * obj0 = 0 ;
4886 PyObject * obj1 = 0 ;
4887 char * kwnames[] = {
4888 (char *) "self",(char *) "w", NULL
4889 };
4890
4891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4893 if (!SWIG_IsOK(res1)) {
4894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4895 }
4896 arg1 = reinterpret_cast< wxSize * >(argp1);
4897 ecode2 = SWIG_AsVal_int(obj1, &val2);
4898 if (!SWIG_IsOK(ecode2)) {
4899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4900 }
4901 arg2 = static_cast< int >(val2);
4902 {
4903 PyThreadState* __tstate = wxPyBeginAllowThreads();
4904 (arg1)->SetWidth(arg2);
4905 wxPyEndAllowThreads(__tstate);
4906 if (PyErr_Occurred()) SWIG_fail;
4907 }
4908 resultobj = SWIG_Py_Void();
4909 return resultobj;
4910 fail:
4911 return NULL;
4912 }
4913
4914
4915 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4916 PyObject *resultobj = 0;
4917 wxSize *arg1 = (wxSize *) 0 ;
4918 int arg2 ;
4919 void *argp1 = 0 ;
4920 int res1 = 0 ;
4921 int val2 ;
4922 int ecode2 = 0 ;
4923 PyObject * obj0 = 0 ;
4924 PyObject * obj1 = 0 ;
4925 char * kwnames[] = {
4926 (char *) "self",(char *) "h", NULL
4927 };
4928
4929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4931 if (!SWIG_IsOK(res1)) {
4932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4933 }
4934 arg1 = reinterpret_cast< wxSize * >(argp1);
4935 ecode2 = SWIG_AsVal_int(obj1, &val2);
4936 if (!SWIG_IsOK(ecode2)) {
4937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4938 }
4939 arg2 = static_cast< int >(val2);
4940 {
4941 PyThreadState* __tstate = wxPyBeginAllowThreads();
4942 (arg1)->SetHeight(arg2);
4943 wxPyEndAllowThreads(__tstate);
4944 if (PyErr_Occurred()) SWIG_fail;
4945 }
4946 resultobj = SWIG_Py_Void();
4947 return resultobj;
4948 fail:
4949 return NULL;
4950 }
4951
4952
4953 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4954 PyObject *resultobj = 0;
4955 wxSize *arg1 = (wxSize *) 0 ;
4956 int result;
4957 void *argp1 = 0 ;
4958 int res1 = 0 ;
4959 PyObject *swig_obj[1] ;
4960
4961 if (!args) SWIG_fail;
4962 swig_obj[0] = args;
4963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4964 if (!SWIG_IsOK(res1)) {
4965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4966 }
4967 arg1 = reinterpret_cast< wxSize * >(argp1);
4968 {
4969 PyThreadState* __tstate = wxPyBeginAllowThreads();
4970 result = (int)((wxSize const *)arg1)->GetWidth();
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 resultobj = SWIG_From_int(static_cast< int >(result));
4975 return resultobj;
4976 fail:
4977 return NULL;
4978 }
4979
4980
4981 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4982 PyObject *resultobj = 0;
4983 wxSize *arg1 = (wxSize *) 0 ;
4984 int result;
4985 void *argp1 = 0 ;
4986 int res1 = 0 ;
4987 PyObject *swig_obj[1] ;
4988
4989 if (!args) SWIG_fail;
4990 swig_obj[0] = args;
4991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4992 if (!SWIG_IsOK(res1)) {
4993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4994 }
4995 arg1 = reinterpret_cast< wxSize * >(argp1);
4996 {
4997 PyThreadState* __tstate = wxPyBeginAllowThreads();
4998 result = (int)((wxSize const *)arg1)->GetHeight();
4999 wxPyEndAllowThreads(__tstate);
5000 if (PyErr_Occurred()) SWIG_fail;
5001 }
5002 resultobj = SWIG_From_int(static_cast< int >(result));
5003 return resultobj;
5004 fail:
5005 return NULL;
5006 }
5007
5008
5009 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5010 PyObject *resultobj = 0;
5011 wxSize *arg1 = (wxSize *) 0 ;
5012 bool result;
5013 void *argp1 = 0 ;
5014 int res1 = 0 ;
5015 PyObject *swig_obj[1] ;
5016
5017 if (!args) SWIG_fail;
5018 swig_obj[0] = args;
5019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5020 if (!SWIG_IsOK(res1)) {
5021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5022 }
5023 arg1 = reinterpret_cast< wxSize * >(argp1);
5024 {
5025 PyThreadState* __tstate = wxPyBeginAllowThreads();
5026 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5027 wxPyEndAllowThreads(__tstate);
5028 if (PyErr_Occurred()) SWIG_fail;
5029 }
5030 {
5031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5032 }
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5040 PyObject *resultobj = 0;
5041 wxSize *arg1 = (wxSize *) 0 ;
5042 wxSize *arg2 = 0 ;
5043 void *argp1 = 0 ;
5044 int res1 = 0 ;
5045 wxSize temp2 ;
5046 PyObject * obj0 = 0 ;
5047 PyObject * obj1 = 0 ;
5048 char * kwnames[] = {
5049 (char *) "self",(char *) "size", NULL
5050 };
5051
5052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5054 if (!SWIG_IsOK(res1)) {
5055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5056 }
5057 arg1 = reinterpret_cast< wxSize * >(argp1);
5058 {
5059 arg2 = &temp2;
5060 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5061 }
5062 {
5063 PyThreadState* __tstate = wxPyBeginAllowThreads();
5064 (arg1)->SetDefaults((wxSize const &)*arg2);
5065 wxPyEndAllowThreads(__tstate);
5066 if (PyErr_Occurred()) SWIG_fail;
5067 }
5068 resultobj = SWIG_Py_Void();
5069 return resultobj;
5070 fail:
5071 return NULL;
5072 }
5073
5074
5075 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5076 PyObject *resultobj = 0;
5077 wxSize *arg1 = (wxSize *) 0 ;
5078 PyObject *result = 0 ;
5079 void *argp1 = 0 ;
5080 int res1 = 0 ;
5081 PyObject *swig_obj[1] ;
5082
5083 if (!args) SWIG_fail;
5084 swig_obj[0] = args;
5085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5086 if (!SWIG_IsOK(res1)) {
5087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5088 }
5089 arg1 = reinterpret_cast< wxSize * >(argp1);
5090 {
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 result = (PyObject *)wxSize_Get(arg1);
5093 wxPyEndAllowThreads(__tstate);
5094 if (PyErr_Occurred()) SWIG_fail;
5095 }
5096 resultobj = result;
5097 return resultobj;
5098 fail:
5099 return NULL;
5100 }
5101
5102
5103 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5104 PyObject *obj;
5105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5106 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5107 return SWIG_Py_Void();
5108 }
5109
5110 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5111 return SWIG_Python_InitShadowInstance(args);
5112 }
5113
5114 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5115 PyObject *resultobj = 0;
5116 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5117 double arg2 ;
5118 void *argp1 = 0 ;
5119 int res1 = 0 ;
5120 double val2 ;
5121 int ecode2 = 0 ;
5122 PyObject *swig_obj[2] ;
5123
5124 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5126 if (!SWIG_IsOK(res1)) {
5127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5128 }
5129 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5130 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5131 if (!SWIG_IsOK(ecode2)) {
5132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5133 }
5134 arg2 = static_cast< double >(val2);
5135 if (arg1) (arg1)->x = arg2;
5136
5137 resultobj = SWIG_Py_Void();
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5145 PyObject *resultobj = 0;
5146 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5147 double result;
5148 void *argp1 = 0 ;
5149 int res1 = 0 ;
5150 PyObject *swig_obj[1] ;
5151
5152 if (!args) SWIG_fail;
5153 swig_obj[0] = args;
5154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5155 if (!SWIG_IsOK(res1)) {
5156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5157 }
5158 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5159 result = (double) ((arg1)->x);
5160 resultobj = SWIG_From_double(static_cast< double >(result));
5161 return resultobj;
5162 fail:
5163 return NULL;
5164 }
5165
5166
5167 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5168 PyObject *resultobj = 0;
5169 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5170 double arg2 ;
5171 void *argp1 = 0 ;
5172 int res1 = 0 ;
5173 double val2 ;
5174 int ecode2 = 0 ;
5175 PyObject *swig_obj[2] ;
5176
5177 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5179 if (!SWIG_IsOK(res1)) {
5180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5181 }
5182 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5183 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5184 if (!SWIG_IsOK(ecode2)) {
5185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5186 }
5187 arg2 = static_cast< double >(val2);
5188 if (arg1) (arg1)->y = arg2;
5189
5190 resultobj = SWIG_Py_Void();
5191 return resultobj;
5192 fail:
5193 return NULL;
5194 }
5195
5196
5197 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 PyObject *resultobj = 0;
5199 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5200 double result;
5201 void *argp1 = 0 ;
5202 int res1 = 0 ;
5203 PyObject *swig_obj[1] ;
5204
5205 if (!args) SWIG_fail;
5206 swig_obj[0] = args;
5207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5208 if (!SWIG_IsOK(res1)) {
5209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5210 }
5211 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5212 result = (double) ((arg1)->y);
5213 resultobj = SWIG_From_double(static_cast< double >(result));
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = 0;
5222 double arg1 = (double) 0.0 ;
5223 double arg2 = (double) 0.0 ;
5224 wxRealPoint *result = 0 ;
5225 double val1 ;
5226 int ecode1 = 0 ;
5227 double val2 ;
5228 int ecode2 = 0 ;
5229 PyObject * obj0 = 0 ;
5230 PyObject * obj1 = 0 ;
5231 char * kwnames[] = {
5232 (char *) "x",(char *) "y", NULL
5233 };
5234
5235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5236 if (obj0) {
5237 ecode1 = SWIG_AsVal_double(obj0, &val1);
5238 if (!SWIG_IsOK(ecode1)) {
5239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5240 }
5241 arg1 = static_cast< double >(val1);
5242 }
5243 if (obj1) {
5244 ecode2 = SWIG_AsVal_double(obj1, &val2);
5245 if (!SWIG_IsOK(ecode2)) {
5246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5247 }
5248 arg2 = static_cast< double >(val2);
5249 }
5250 {
5251 PyThreadState* __tstate = wxPyBeginAllowThreads();
5252 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5253 wxPyEndAllowThreads(__tstate);
5254 if (PyErr_Occurred()) SWIG_fail;
5255 }
5256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5264 PyObject *resultobj = 0;
5265 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 PyObject *swig_obj[1] ;
5269
5270 if (!args) SWIG_fail;
5271 swig_obj[0] = args;
5272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5273 if (!SWIG_IsOK(res1)) {
5274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5275 }
5276 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5277 {
5278 PyThreadState* __tstate = wxPyBeginAllowThreads();
5279 delete arg1;
5280
5281 wxPyEndAllowThreads(__tstate);
5282 if (PyErr_Occurred()) SWIG_fail;
5283 }
5284 resultobj = SWIG_Py_Void();
5285 return resultobj;
5286 fail:
5287 return NULL;
5288 }
5289
5290
5291 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5292 PyObject *resultobj = 0;
5293 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5294 PyObject *arg2 = (PyObject *) 0 ;
5295 bool result;
5296 void *argp1 = 0 ;
5297 int res1 = 0 ;
5298 PyObject * obj0 = 0 ;
5299 PyObject * obj1 = 0 ;
5300 char * kwnames[] = {
5301 (char *) "self",(char *) "other", NULL
5302 };
5303
5304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5306 if (!SWIG_IsOK(res1)) {
5307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5308 }
5309 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5310 arg2 = obj1;
5311 {
5312 result = (bool)wxRealPoint___eq__(arg1,arg2);
5313 if (PyErr_Occurred()) SWIG_fail;
5314 }
5315 {
5316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5317 }
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5325 PyObject *resultobj = 0;
5326 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5327 PyObject *arg2 = (PyObject *) 0 ;
5328 bool result;
5329 void *argp1 = 0 ;
5330 int res1 = 0 ;
5331 PyObject * obj0 = 0 ;
5332 PyObject * obj1 = 0 ;
5333 char * kwnames[] = {
5334 (char *) "self",(char *) "other", NULL
5335 };
5336
5337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5339 if (!SWIG_IsOK(res1)) {
5340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5341 }
5342 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5343 arg2 = obj1;
5344 {
5345 result = (bool)wxRealPoint___ne__(arg1,arg2);
5346 if (PyErr_Occurred()) SWIG_fail;
5347 }
5348 {
5349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5350 }
5351 return resultobj;
5352 fail:
5353 return NULL;
5354 }
5355
5356
5357 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5358 PyObject *resultobj = 0;
5359 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5360 wxRealPoint *arg2 = 0 ;
5361 wxRealPoint result;
5362 void *argp1 = 0 ;
5363 int res1 = 0 ;
5364 wxRealPoint temp2 ;
5365 PyObject * obj0 = 0 ;
5366 PyObject * obj1 = 0 ;
5367 char * kwnames[] = {
5368 (char *) "self",(char *) "pt", NULL
5369 };
5370
5371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5373 if (!SWIG_IsOK(res1)) {
5374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5375 }
5376 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5377 {
5378 arg2 = &temp2;
5379 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5380 }
5381 {
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5388 return resultobj;
5389 fail:
5390 return NULL;
5391 }
5392
5393
5394 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5395 PyObject *resultobj = 0;
5396 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5397 wxRealPoint *arg2 = 0 ;
5398 wxRealPoint result;
5399 void *argp1 = 0 ;
5400 int res1 = 0 ;
5401 wxRealPoint temp2 ;
5402 PyObject * obj0 = 0 ;
5403 PyObject * obj1 = 0 ;
5404 char * kwnames[] = {
5405 (char *) "self",(char *) "pt", NULL
5406 };
5407
5408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5410 if (!SWIG_IsOK(res1)) {
5411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5412 }
5413 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5414 {
5415 arg2 = &temp2;
5416 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5417 }
5418 {
5419 PyThreadState* __tstate = wxPyBeginAllowThreads();
5420 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5421 wxPyEndAllowThreads(__tstate);
5422 if (PyErr_Occurred()) SWIG_fail;
5423 }
5424 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5425 return resultobj;
5426 fail:
5427 return NULL;
5428 }
5429
5430
5431 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5432 PyObject *resultobj = 0;
5433 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5434 double arg2 ;
5435 double arg3 ;
5436 void *argp1 = 0 ;
5437 int res1 = 0 ;
5438 double val2 ;
5439 int ecode2 = 0 ;
5440 double val3 ;
5441 int ecode3 = 0 ;
5442 PyObject * obj0 = 0 ;
5443 PyObject * obj1 = 0 ;
5444 PyObject * obj2 = 0 ;
5445 char * kwnames[] = {
5446 (char *) "self",(char *) "x",(char *) "y", NULL
5447 };
5448
5449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5451 if (!SWIG_IsOK(res1)) {
5452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5453 }
5454 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5455 ecode2 = SWIG_AsVal_double(obj1, &val2);
5456 if (!SWIG_IsOK(ecode2)) {
5457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5458 }
5459 arg2 = static_cast< double >(val2);
5460 ecode3 = SWIG_AsVal_double(obj2, &val3);
5461 if (!SWIG_IsOK(ecode3)) {
5462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5463 }
5464 arg3 = static_cast< double >(val3);
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 wxRealPoint_Set(arg1,arg2,arg3);
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 resultobj = SWIG_Py_Void();
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5479 PyObject *resultobj = 0;
5480 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5481 PyObject *result = 0 ;
5482 void *argp1 = 0 ;
5483 int res1 = 0 ;
5484 PyObject *swig_obj[1] ;
5485
5486 if (!args) SWIG_fail;
5487 swig_obj[0] = args;
5488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5489 if (!SWIG_IsOK(res1)) {
5490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5491 }
5492 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = (PyObject *)wxRealPoint_Get(arg1);
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 resultobj = result;
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 PyObject *obj;
5508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5509 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5510 return SWIG_Py_Void();
5511 }
5512
5513 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5514 return SWIG_Python_InitShadowInstance(args);
5515 }
5516
5517 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5518 PyObject *resultobj = 0;
5519 wxPoint *arg1 = (wxPoint *) 0 ;
5520 int arg2 ;
5521 void *argp1 = 0 ;
5522 int res1 = 0 ;
5523 int val2 ;
5524 int ecode2 = 0 ;
5525 PyObject *swig_obj[2] ;
5526
5527 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5529 if (!SWIG_IsOK(res1)) {
5530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5531 }
5532 arg1 = reinterpret_cast< wxPoint * >(argp1);
5533 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5534 if (!SWIG_IsOK(ecode2)) {
5535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5536 }
5537 arg2 = static_cast< int >(val2);
5538 if (arg1) (arg1)->x = arg2;
5539
5540 resultobj = SWIG_Py_Void();
5541 return resultobj;
5542 fail:
5543 return NULL;
5544 }
5545
5546
5547 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5548 PyObject *resultobj = 0;
5549 wxPoint *arg1 = (wxPoint *) 0 ;
5550 int result;
5551 void *argp1 = 0 ;
5552 int res1 = 0 ;
5553 PyObject *swig_obj[1] ;
5554
5555 if (!args) SWIG_fail;
5556 swig_obj[0] = args;
5557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5558 if (!SWIG_IsOK(res1)) {
5559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5560 }
5561 arg1 = reinterpret_cast< wxPoint * >(argp1);
5562 result = (int) ((arg1)->x);
5563 resultobj = SWIG_From_int(static_cast< int >(result));
5564 return resultobj;
5565 fail:
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 wxPoint *arg1 = (wxPoint *) 0 ;
5573 int arg2 ;
5574 void *argp1 = 0 ;
5575 int res1 = 0 ;
5576 int val2 ;
5577 int ecode2 = 0 ;
5578 PyObject *swig_obj[2] ;
5579
5580 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5582 if (!SWIG_IsOK(res1)) {
5583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5584 }
5585 arg1 = reinterpret_cast< wxPoint * >(argp1);
5586 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5587 if (!SWIG_IsOK(ecode2)) {
5588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5589 }
5590 arg2 = static_cast< int >(val2);
5591 if (arg1) (arg1)->y = arg2;
5592
5593 resultobj = SWIG_Py_Void();
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 PyObject *resultobj = 0;
5602 wxPoint *arg1 = (wxPoint *) 0 ;
5603 int result;
5604 void *argp1 = 0 ;
5605 int res1 = 0 ;
5606 PyObject *swig_obj[1] ;
5607
5608 if (!args) SWIG_fail;
5609 swig_obj[0] = args;
5610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5611 if (!SWIG_IsOK(res1)) {
5612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5613 }
5614 arg1 = reinterpret_cast< wxPoint * >(argp1);
5615 result = (int) ((arg1)->y);
5616 resultobj = SWIG_From_int(static_cast< int >(result));
5617 return resultobj;
5618 fail:
5619 return NULL;
5620 }
5621
5622
5623 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5624 PyObject *resultobj = 0;
5625 int arg1 = (int) 0 ;
5626 int arg2 = (int) 0 ;
5627 wxPoint *result = 0 ;
5628 int val1 ;
5629 int ecode1 = 0 ;
5630 int val2 ;
5631 int ecode2 = 0 ;
5632 PyObject * obj0 = 0 ;
5633 PyObject * obj1 = 0 ;
5634 char * kwnames[] = {
5635 (char *) "x",(char *) "y", NULL
5636 };
5637
5638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5639 if (obj0) {
5640 ecode1 = SWIG_AsVal_int(obj0, &val1);
5641 if (!SWIG_IsOK(ecode1)) {
5642 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5643 }
5644 arg1 = static_cast< int >(val1);
5645 }
5646 if (obj1) {
5647 ecode2 = SWIG_AsVal_int(obj1, &val2);
5648 if (!SWIG_IsOK(ecode2)) {
5649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5650 }
5651 arg2 = static_cast< int >(val2);
5652 }
5653 {
5654 PyThreadState* __tstate = wxPyBeginAllowThreads();
5655 result = (wxPoint *)new wxPoint(arg1,arg2);
5656 wxPyEndAllowThreads(__tstate);
5657 if (PyErr_Occurred()) SWIG_fail;
5658 }
5659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5660 return resultobj;
5661 fail:
5662 return NULL;
5663 }
5664
5665
5666 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5667 PyObject *resultobj = 0;
5668 wxPoint *arg1 = (wxPoint *) 0 ;
5669 void *argp1 = 0 ;
5670 int res1 = 0 ;
5671 PyObject *swig_obj[1] ;
5672
5673 if (!args) SWIG_fail;
5674 swig_obj[0] = args;
5675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5676 if (!SWIG_IsOK(res1)) {
5677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5678 }
5679 arg1 = reinterpret_cast< wxPoint * >(argp1);
5680 {
5681 PyThreadState* __tstate = wxPyBeginAllowThreads();
5682 delete arg1;
5683
5684 wxPyEndAllowThreads(__tstate);
5685 if (PyErr_Occurred()) SWIG_fail;
5686 }
5687 resultobj = SWIG_Py_Void();
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj = 0;
5696 wxPoint *arg1 = (wxPoint *) 0 ;
5697 PyObject *arg2 = (PyObject *) 0 ;
5698 bool result;
5699 void *argp1 = 0 ;
5700 int res1 = 0 ;
5701 PyObject * obj0 = 0 ;
5702 PyObject * obj1 = 0 ;
5703 char * kwnames[] = {
5704 (char *) "self",(char *) "other", NULL
5705 };
5706
5707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5709 if (!SWIG_IsOK(res1)) {
5710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5711 }
5712 arg1 = reinterpret_cast< wxPoint * >(argp1);
5713 arg2 = obj1;
5714 {
5715 result = (bool)wxPoint___eq__(arg1,arg2);
5716 if (PyErr_Occurred()) SWIG_fail;
5717 }
5718 {
5719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5720 }
5721 return resultobj;
5722 fail:
5723 return NULL;
5724 }
5725
5726
5727 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5728 PyObject *resultobj = 0;
5729 wxPoint *arg1 = (wxPoint *) 0 ;
5730 PyObject *arg2 = (PyObject *) 0 ;
5731 bool result;
5732 void *argp1 = 0 ;
5733 int res1 = 0 ;
5734 PyObject * obj0 = 0 ;
5735 PyObject * obj1 = 0 ;
5736 char * kwnames[] = {
5737 (char *) "self",(char *) "other", NULL
5738 };
5739
5740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5742 if (!SWIG_IsOK(res1)) {
5743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5744 }
5745 arg1 = reinterpret_cast< wxPoint * >(argp1);
5746 arg2 = obj1;
5747 {
5748 result = (bool)wxPoint___ne__(arg1,arg2);
5749 if (PyErr_Occurred()) SWIG_fail;
5750 }
5751 {
5752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5753 }
5754 return resultobj;
5755 fail:
5756 return NULL;
5757 }
5758
5759
5760 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5761 PyObject *resultobj = 0;
5762 wxPoint *arg1 = (wxPoint *) 0 ;
5763 wxPoint *arg2 = 0 ;
5764 wxPoint result;
5765 void *argp1 = 0 ;
5766 int res1 = 0 ;
5767 wxPoint temp2 ;
5768 PyObject * obj0 = 0 ;
5769 PyObject * obj1 = 0 ;
5770 char * kwnames[] = {
5771 (char *) "self",(char *) "pt", NULL
5772 };
5773
5774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5776 if (!SWIG_IsOK(res1)) {
5777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5778 }
5779 arg1 = reinterpret_cast< wxPoint * >(argp1);
5780 {
5781 arg2 = &temp2;
5782 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5783 }
5784 {
5785 PyThreadState* __tstate = wxPyBeginAllowThreads();
5786 result = (arg1)->operator +((wxPoint const &)*arg2);
5787 wxPyEndAllowThreads(__tstate);
5788 if (PyErr_Occurred()) SWIG_fail;
5789 }
5790 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5791 return resultobj;
5792 fail:
5793 return NULL;
5794 }
5795
5796
5797 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5798 PyObject *resultobj = 0;
5799 wxPoint *arg1 = (wxPoint *) 0 ;
5800 wxPoint *arg2 = 0 ;
5801 wxPoint result;
5802 void *argp1 = 0 ;
5803 int res1 = 0 ;
5804 wxPoint temp2 ;
5805 PyObject * obj0 = 0 ;
5806 PyObject * obj1 = 0 ;
5807 char * kwnames[] = {
5808 (char *) "self",(char *) "pt", NULL
5809 };
5810
5811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5813 if (!SWIG_IsOK(res1)) {
5814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5815 }
5816 arg1 = reinterpret_cast< wxPoint * >(argp1);
5817 {
5818 arg2 = &temp2;
5819 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5820 }
5821 {
5822 PyThreadState* __tstate = wxPyBeginAllowThreads();
5823 result = (arg1)->operator -((wxPoint const &)*arg2);
5824 wxPyEndAllowThreads(__tstate);
5825 if (PyErr_Occurred()) SWIG_fail;
5826 }
5827 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5828 return resultobj;
5829 fail:
5830 return NULL;
5831 }
5832
5833
5834 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5835 PyObject *resultobj = 0;
5836 wxPoint *arg1 = (wxPoint *) 0 ;
5837 wxPoint *arg2 = 0 ;
5838 wxPoint *result = 0 ;
5839 void *argp1 = 0 ;
5840 int res1 = 0 ;
5841 wxPoint temp2 ;
5842 PyObject * obj0 = 0 ;
5843 PyObject * obj1 = 0 ;
5844 char * kwnames[] = {
5845 (char *) "self",(char *) "pt", NULL
5846 };
5847
5848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5850 if (!SWIG_IsOK(res1)) {
5851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5852 }
5853 arg1 = reinterpret_cast< wxPoint * >(argp1);
5854 {
5855 arg2 = &temp2;
5856 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5857 }
5858 {
5859 PyThreadState* __tstate = wxPyBeginAllowThreads();
5860 {
5861 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5862 result = (wxPoint *) &_result_ref;
5863 }
5864 wxPyEndAllowThreads(__tstate);
5865 if (PyErr_Occurred()) SWIG_fail;
5866 }
5867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5868 return resultobj;
5869 fail:
5870 return NULL;
5871 }
5872
5873
5874 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj = 0;
5876 wxPoint *arg1 = (wxPoint *) 0 ;
5877 wxPoint *arg2 = 0 ;
5878 wxPoint *result = 0 ;
5879 void *argp1 = 0 ;
5880 int res1 = 0 ;
5881 wxPoint temp2 ;
5882 PyObject * obj0 = 0 ;
5883 PyObject * obj1 = 0 ;
5884 char * kwnames[] = {
5885 (char *) "self",(char *) "pt", NULL
5886 };
5887
5888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5890 if (!SWIG_IsOK(res1)) {
5891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5892 }
5893 arg1 = reinterpret_cast< wxPoint * >(argp1);
5894 {
5895 arg2 = &temp2;
5896 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5897 }
5898 {
5899 PyThreadState* __tstate = wxPyBeginAllowThreads();
5900 {
5901 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5902 result = (wxPoint *) &_result_ref;
5903 }
5904 wxPyEndAllowThreads(__tstate);
5905 if (PyErr_Occurred()) SWIG_fail;
5906 }
5907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5908 return resultobj;
5909 fail:
5910 return NULL;
5911 }
5912
5913
5914 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5915 PyObject *resultobj = 0;
5916 wxPoint *arg1 = (wxPoint *) 0 ;
5917 long arg2 ;
5918 long arg3 ;
5919 void *argp1 = 0 ;
5920 int res1 = 0 ;
5921 long val2 ;
5922 int ecode2 = 0 ;
5923 long val3 ;
5924 int ecode3 = 0 ;
5925 PyObject * obj0 = 0 ;
5926 PyObject * obj1 = 0 ;
5927 PyObject * obj2 = 0 ;
5928 char * kwnames[] = {
5929 (char *) "self",(char *) "x",(char *) "y", NULL
5930 };
5931
5932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5934 if (!SWIG_IsOK(res1)) {
5935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5936 }
5937 arg1 = reinterpret_cast< wxPoint * >(argp1);
5938 ecode2 = SWIG_AsVal_long(obj1, &val2);
5939 if (!SWIG_IsOK(ecode2)) {
5940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5941 }
5942 arg2 = static_cast< long >(val2);
5943 ecode3 = SWIG_AsVal_long(obj2, &val3);
5944 if (!SWIG_IsOK(ecode3)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5946 }
5947 arg3 = static_cast< long >(val3);
5948 {
5949 PyThreadState* __tstate = wxPyBeginAllowThreads();
5950 wxPoint_Set(arg1,arg2,arg3);
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_Py_Void();
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 PyObject *result = 0 ;
5965 void *argp1 = 0 ;
5966 int res1 = 0 ;
5967 PyObject *swig_obj[1] ;
5968
5969 if (!args) SWIG_fail;
5970 swig_obj[0] = args;
5971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5972 if (!SWIG_IsOK(res1)) {
5973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5974 }
5975 arg1 = reinterpret_cast< wxPoint * >(argp1);
5976 {
5977 PyThreadState* __tstate = wxPyBeginAllowThreads();
5978 result = (PyObject *)wxPoint_Get(arg1);
5979 wxPyEndAllowThreads(__tstate);
5980 if (PyErr_Occurred()) SWIG_fail;
5981 }
5982 resultobj = result;
5983 return resultobj;
5984 fail:
5985 return NULL;
5986 }
5987
5988
5989 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5990 PyObject *obj;
5991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5992 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5993 return SWIG_Py_Void();
5994 }
5995
5996 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5997 return SWIG_Python_InitShadowInstance(args);
5998 }
5999
6000 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj = 0;
6002 int arg1 = (int) 0 ;
6003 int arg2 = (int) 0 ;
6004 int arg3 = (int) 0 ;
6005 int arg4 = (int) 0 ;
6006 wxRect *result = 0 ;
6007 int val1 ;
6008 int ecode1 = 0 ;
6009 int val2 ;
6010 int ecode2 = 0 ;
6011 int val3 ;
6012 int ecode3 = 0 ;
6013 int val4 ;
6014 int ecode4 = 0 ;
6015 PyObject * obj0 = 0 ;
6016 PyObject * obj1 = 0 ;
6017 PyObject * obj2 = 0 ;
6018 PyObject * obj3 = 0 ;
6019 char * kwnames[] = {
6020 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6021 };
6022
6023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6024 if (obj0) {
6025 ecode1 = SWIG_AsVal_int(obj0, &val1);
6026 if (!SWIG_IsOK(ecode1)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6028 }
6029 arg1 = static_cast< int >(val1);
6030 }
6031 if (obj1) {
6032 ecode2 = SWIG_AsVal_int(obj1, &val2);
6033 if (!SWIG_IsOK(ecode2)) {
6034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6035 }
6036 arg2 = static_cast< int >(val2);
6037 }
6038 if (obj2) {
6039 ecode3 = SWIG_AsVal_int(obj2, &val3);
6040 if (!SWIG_IsOK(ecode3)) {
6041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6042 }
6043 arg3 = static_cast< int >(val3);
6044 }
6045 if (obj3) {
6046 ecode4 = SWIG_AsVal_int(obj3, &val4);
6047 if (!SWIG_IsOK(ecode4)) {
6048 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6049 }
6050 arg4 = static_cast< int >(val4);
6051 }
6052 {
6053 PyThreadState* __tstate = wxPyBeginAllowThreads();
6054 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6055 wxPyEndAllowThreads(__tstate);
6056 if (PyErr_Occurred()) SWIG_fail;
6057 }
6058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6059 return resultobj;
6060 fail:
6061 return NULL;
6062 }
6063
6064
6065 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6066 PyObject *resultobj = 0;
6067 wxPoint *arg1 = 0 ;
6068 wxPoint *arg2 = 0 ;
6069 wxRect *result = 0 ;
6070 wxPoint temp1 ;
6071 wxPoint temp2 ;
6072 PyObject * obj0 = 0 ;
6073 PyObject * obj1 = 0 ;
6074 char * kwnames[] = {
6075 (char *) "topLeft",(char *) "bottomRight", NULL
6076 };
6077
6078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6079 {
6080 arg1 = &temp1;
6081 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6082 }
6083 {
6084 arg2 = &temp2;
6085 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6086 }
6087 {
6088 PyThreadState* __tstate = wxPyBeginAllowThreads();
6089 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6090 wxPyEndAllowThreads(__tstate);
6091 if (PyErr_Occurred()) SWIG_fail;
6092 }
6093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6094 return resultobj;
6095 fail:
6096 return NULL;
6097 }
6098
6099
6100 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6101 PyObject *resultobj = 0;
6102 wxPoint *arg1 = 0 ;
6103 wxSize *arg2 = 0 ;
6104 wxRect *result = 0 ;
6105 wxPoint temp1 ;
6106 wxSize temp2 ;
6107 PyObject * obj0 = 0 ;
6108 PyObject * obj1 = 0 ;
6109 char * kwnames[] = {
6110 (char *) "pos",(char *) "size", NULL
6111 };
6112
6113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6114 {
6115 arg1 = &temp1;
6116 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6117 }
6118 {
6119 arg2 = &temp2;
6120 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6121 }
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6129 return resultobj;
6130 fail:
6131 return NULL;
6132 }
6133
6134
6135 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj = 0;
6137 wxSize *arg1 = 0 ;
6138 wxRect *result = 0 ;
6139 wxSize temp1 ;
6140 PyObject * obj0 = 0 ;
6141 char * kwnames[] = {
6142 (char *) "size", NULL
6143 };
6144
6145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6146 {
6147 arg1 = &temp1;
6148 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6149 }
6150 {
6151 PyThreadState* __tstate = wxPyBeginAllowThreads();
6152 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6153 wxPyEndAllowThreads(__tstate);
6154 if (PyErr_Occurred()) SWIG_fail;
6155 }
6156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6157 return resultobj;
6158 fail:
6159 return NULL;
6160 }
6161
6162
6163 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6164 PyObject *resultobj = 0;
6165 wxRect *arg1 = (wxRect *) 0 ;
6166 void *argp1 = 0 ;
6167 int res1 = 0 ;
6168 PyObject *swig_obj[1] ;
6169
6170 if (!args) SWIG_fail;
6171 swig_obj[0] = args;
6172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6173 if (!SWIG_IsOK(res1)) {
6174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6175 }
6176 arg1 = reinterpret_cast< wxRect * >(argp1);
6177 {
6178 PyThreadState* __tstate = wxPyBeginAllowThreads();
6179 delete arg1;
6180
6181 wxPyEndAllowThreads(__tstate);
6182 if (PyErr_Occurred()) SWIG_fail;
6183 }
6184 resultobj = SWIG_Py_Void();
6185 return resultobj;
6186 fail:
6187 return NULL;
6188 }
6189
6190
6191 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6192 PyObject *resultobj = 0;
6193 wxRect *arg1 = (wxRect *) 0 ;
6194 int result;
6195 void *argp1 = 0 ;
6196 int res1 = 0 ;
6197 PyObject *swig_obj[1] ;
6198
6199 if (!args) SWIG_fail;
6200 swig_obj[0] = args;
6201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6202 if (!SWIG_IsOK(res1)) {
6203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6204 }
6205 arg1 = reinterpret_cast< wxRect * >(argp1);
6206 {
6207 PyThreadState* __tstate = wxPyBeginAllowThreads();
6208 result = (int)((wxRect const *)arg1)->GetX();
6209 wxPyEndAllowThreads(__tstate);
6210 if (PyErr_Occurred()) SWIG_fail;
6211 }
6212 resultobj = SWIG_From_int(static_cast< int >(result));
6213 return resultobj;
6214 fail:
6215 return NULL;
6216 }
6217
6218
6219 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6220 PyObject *resultobj = 0;
6221 wxRect *arg1 = (wxRect *) 0 ;
6222 int arg2 ;
6223 void *argp1 = 0 ;
6224 int res1 = 0 ;
6225 int val2 ;
6226 int ecode2 = 0 ;
6227 PyObject * obj0 = 0 ;
6228 PyObject * obj1 = 0 ;
6229 char * kwnames[] = {
6230 (char *) "self",(char *) "x", NULL
6231 };
6232
6233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6235 if (!SWIG_IsOK(res1)) {
6236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6237 }
6238 arg1 = reinterpret_cast< wxRect * >(argp1);
6239 ecode2 = SWIG_AsVal_int(obj1, &val2);
6240 if (!SWIG_IsOK(ecode2)) {
6241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6242 }
6243 arg2 = static_cast< int >(val2);
6244 {
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 (arg1)->SetX(arg2);
6247 wxPyEndAllowThreads(__tstate);
6248 if (PyErr_Occurred()) SWIG_fail;
6249 }
6250 resultobj = SWIG_Py_Void();
6251 return resultobj;
6252 fail:
6253 return NULL;
6254 }
6255
6256
6257 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6258 PyObject *resultobj = 0;
6259 wxRect *arg1 = (wxRect *) 0 ;
6260 int result;
6261 void *argp1 = 0 ;
6262 int res1 = 0 ;
6263 PyObject *swig_obj[1] ;
6264
6265 if (!args) SWIG_fail;
6266 swig_obj[0] = args;
6267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6268 if (!SWIG_IsOK(res1)) {
6269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6270 }
6271 arg1 = reinterpret_cast< wxRect * >(argp1);
6272 {
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 result = (int)(arg1)->GetY();
6275 wxPyEndAllowThreads(__tstate);
6276 if (PyErr_Occurred()) SWIG_fail;
6277 }
6278 resultobj = SWIG_From_int(static_cast< int >(result));
6279 return resultobj;
6280 fail:
6281 return NULL;
6282 }
6283
6284
6285 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6286 PyObject *resultobj = 0;
6287 wxRect *arg1 = (wxRect *) 0 ;
6288 int arg2 ;
6289 void *argp1 = 0 ;
6290 int res1 = 0 ;
6291 int val2 ;
6292 int ecode2 = 0 ;
6293 PyObject * obj0 = 0 ;
6294 PyObject * obj1 = 0 ;
6295 char * kwnames[] = {
6296 (char *) "self",(char *) "y", NULL
6297 };
6298
6299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6301 if (!SWIG_IsOK(res1)) {
6302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6303 }
6304 arg1 = reinterpret_cast< wxRect * >(argp1);
6305 ecode2 = SWIG_AsVal_int(obj1, &val2);
6306 if (!SWIG_IsOK(ecode2)) {
6307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6308 }
6309 arg2 = static_cast< int >(val2);
6310 {
6311 PyThreadState* __tstate = wxPyBeginAllowThreads();
6312 (arg1)->SetY(arg2);
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 resultobj = SWIG_Py_Void();
6317 return resultobj;
6318 fail:
6319 return NULL;
6320 }
6321
6322
6323 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6324 PyObject *resultobj = 0;
6325 wxRect *arg1 = (wxRect *) 0 ;
6326 int result;
6327 void *argp1 = 0 ;
6328 int res1 = 0 ;
6329 PyObject *swig_obj[1] ;
6330
6331 if (!args) SWIG_fail;
6332 swig_obj[0] = args;
6333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6334 if (!SWIG_IsOK(res1)) {
6335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6336 }
6337 arg1 = reinterpret_cast< wxRect * >(argp1);
6338 {
6339 PyThreadState* __tstate = wxPyBeginAllowThreads();
6340 result = (int)((wxRect const *)arg1)->GetWidth();
6341 wxPyEndAllowThreads(__tstate);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 resultobj = SWIG_From_int(static_cast< int >(result));
6345 return resultobj;
6346 fail:
6347 return NULL;
6348 }
6349
6350
6351 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj = 0;
6353 wxRect *arg1 = (wxRect *) 0 ;
6354 int arg2 ;
6355 void *argp1 = 0 ;
6356 int res1 = 0 ;
6357 int val2 ;
6358 int ecode2 = 0 ;
6359 PyObject * obj0 = 0 ;
6360 PyObject * obj1 = 0 ;
6361 char * kwnames[] = {
6362 (char *) "self",(char *) "w", NULL
6363 };
6364
6365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6367 if (!SWIG_IsOK(res1)) {
6368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6369 }
6370 arg1 = reinterpret_cast< wxRect * >(argp1);
6371 ecode2 = SWIG_AsVal_int(obj1, &val2);
6372 if (!SWIG_IsOK(ecode2)) {
6373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6374 }
6375 arg2 = static_cast< int >(val2);
6376 {
6377 PyThreadState* __tstate = wxPyBeginAllowThreads();
6378 (arg1)->SetWidth(arg2);
6379 wxPyEndAllowThreads(__tstate);
6380 if (PyErr_Occurred()) SWIG_fail;
6381 }
6382 resultobj = SWIG_Py_Void();
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6390 PyObject *resultobj = 0;
6391 wxRect *arg1 = (wxRect *) 0 ;
6392 int result;
6393 void *argp1 = 0 ;
6394 int res1 = 0 ;
6395 PyObject *swig_obj[1] ;
6396
6397 if (!args) SWIG_fail;
6398 swig_obj[0] = args;
6399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6400 if (!SWIG_IsOK(res1)) {
6401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6402 }
6403 arg1 = reinterpret_cast< wxRect * >(argp1);
6404 {
6405 PyThreadState* __tstate = wxPyBeginAllowThreads();
6406 result = (int)((wxRect const *)arg1)->GetHeight();
6407 wxPyEndAllowThreads(__tstate);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 resultobj = SWIG_From_int(static_cast< int >(result));
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj = 0;
6419 wxRect *arg1 = (wxRect *) 0 ;
6420 int arg2 ;
6421 void *argp1 = 0 ;
6422 int res1 = 0 ;
6423 int val2 ;
6424 int ecode2 = 0 ;
6425 PyObject * obj0 = 0 ;
6426 PyObject * obj1 = 0 ;
6427 char * kwnames[] = {
6428 (char *) "self",(char *) "h", NULL
6429 };
6430
6431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6433 if (!SWIG_IsOK(res1)) {
6434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6435 }
6436 arg1 = reinterpret_cast< wxRect * >(argp1);
6437 ecode2 = SWIG_AsVal_int(obj1, &val2);
6438 if (!SWIG_IsOK(ecode2)) {
6439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6440 }
6441 arg2 = static_cast< int >(val2);
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 (arg1)->SetHeight(arg2);
6445 wxPyEndAllowThreads(__tstate);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 resultobj = SWIG_Py_Void();
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6456 PyObject *resultobj = 0;
6457 wxRect *arg1 = (wxRect *) 0 ;
6458 wxPoint result;
6459 void *argp1 = 0 ;
6460 int res1 = 0 ;
6461 PyObject *swig_obj[1] ;
6462
6463 if (!args) SWIG_fail;
6464 swig_obj[0] = args;
6465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6466 if (!SWIG_IsOK(res1)) {
6467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6468 }
6469 arg1 = reinterpret_cast< wxRect * >(argp1);
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 result = ((wxRect const *)arg1)->GetPosition();
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6477 return resultobj;
6478 fail:
6479 return NULL;
6480 }
6481
6482
6483 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6484 PyObject *resultobj = 0;
6485 wxRect *arg1 = (wxRect *) 0 ;
6486 wxPoint *arg2 = 0 ;
6487 void *argp1 = 0 ;
6488 int res1 = 0 ;
6489 wxPoint temp2 ;
6490 PyObject * obj0 = 0 ;
6491 PyObject * obj1 = 0 ;
6492 char * kwnames[] = {
6493 (char *) "self",(char *) "p", NULL
6494 };
6495
6496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6498 if (!SWIG_IsOK(res1)) {
6499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6500 }
6501 arg1 = reinterpret_cast< wxRect * >(argp1);
6502 {
6503 arg2 = &temp2;
6504 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6505 }
6506 {
6507 PyThreadState* __tstate = wxPyBeginAllowThreads();
6508 (arg1)->SetPosition((wxPoint const &)*arg2);
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_Py_Void();
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6520 PyObject *resultobj = 0;
6521 wxRect *arg1 = (wxRect *) 0 ;
6522 wxSize result;
6523 void *argp1 = 0 ;
6524 int res1 = 0 ;
6525 PyObject *swig_obj[1] ;
6526
6527 if (!args) SWIG_fail;
6528 swig_obj[0] = args;
6529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6530 if (!SWIG_IsOK(res1)) {
6531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6532 }
6533 arg1 = reinterpret_cast< wxRect * >(argp1);
6534 {
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = ((wxRect const *)arg1)->GetSize();
6537 wxPyEndAllowThreads(__tstate);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6541 return resultobj;
6542 fail:
6543 return NULL;
6544 }
6545
6546
6547 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj = 0;
6549 wxRect *arg1 = (wxRect *) 0 ;
6550 wxSize *arg2 = 0 ;
6551 void *argp1 = 0 ;
6552 int res1 = 0 ;
6553 wxSize temp2 ;
6554 PyObject * obj0 = 0 ;
6555 PyObject * obj1 = 0 ;
6556 char * kwnames[] = {
6557 (char *) "self",(char *) "s", NULL
6558 };
6559
6560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6562 if (!SWIG_IsOK(res1)) {
6563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6564 }
6565 arg1 = reinterpret_cast< wxRect * >(argp1);
6566 {
6567 arg2 = &temp2;
6568 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6569 }
6570 {
6571 PyThreadState* __tstate = wxPyBeginAllowThreads();
6572 (arg1)->SetSize((wxSize const &)*arg2);
6573 wxPyEndAllowThreads(__tstate);
6574 if (PyErr_Occurred()) SWIG_fail;
6575 }
6576 resultobj = SWIG_Py_Void();
6577 return resultobj;
6578 fail:
6579 return NULL;
6580 }
6581
6582
6583 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6584 PyObject *resultobj = 0;
6585 wxRect *arg1 = (wxRect *) 0 ;
6586 bool result;
6587 void *argp1 = 0 ;
6588 int res1 = 0 ;
6589 PyObject *swig_obj[1] ;
6590
6591 if (!args) SWIG_fail;
6592 swig_obj[0] = args;
6593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6594 if (!SWIG_IsOK(res1)) {
6595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6596 }
6597 arg1 = reinterpret_cast< wxRect * >(argp1);
6598 {
6599 PyThreadState* __tstate = wxPyBeginAllowThreads();
6600 result = (bool)((wxRect const *)arg1)->IsEmpty();
6601 wxPyEndAllowThreads(__tstate);
6602 if (PyErr_Occurred()) SWIG_fail;
6603 }
6604 {
6605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6606 }
6607 return resultobj;
6608 fail:
6609 return NULL;
6610 }
6611
6612
6613 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6614 PyObject *resultobj = 0;
6615 wxRect *arg1 = (wxRect *) 0 ;
6616 wxPoint result;
6617 void *argp1 = 0 ;
6618 int res1 = 0 ;
6619 PyObject *swig_obj[1] ;
6620
6621 if (!args) SWIG_fail;
6622 swig_obj[0] = args;
6623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6624 if (!SWIG_IsOK(res1)) {
6625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6626 }
6627 arg1 = reinterpret_cast< wxRect * >(argp1);
6628 {
6629 PyThreadState* __tstate = wxPyBeginAllowThreads();
6630 result = ((wxRect const *)arg1)->GetTopLeft();
6631 wxPyEndAllowThreads(__tstate);
6632 if (PyErr_Occurred()) SWIG_fail;
6633 }
6634 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6635 return resultobj;
6636 fail:
6637 return NULL;
6638 }
6639
6640
6641 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6642 PyObject *resultobj = 0;
6643 wxRect *arg1 = (wxRect *) 0 ;
6644 wxPoint *arg2 = 0 ;
6645 void *argp1 = 0 ;
6646 int res1 = 0 ;
6647 wxPoint temp2 ;
6648 PyObject * obj0 = 0 ;
6649 PyObject * obj1 = 0 ;
6650 char * kwnames[] = {
6651 (char *) "self",(char *) "p", NULL
6652 };
6653
6654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6656 if (!SWIG_IsOK(res1)) {
6657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6658 }
6659 arg1 = reinterpret_cast< wxRect * >(argp1);
6660 {
6661 arg2 = &temp2;
6662 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6663 }
6664 {
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 resultobj = SWIG_Py_Void();
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6678 PyObject *resultobj = 0;
6679 wxRect *arg1 = (wxRect *) 0 ;
6680 wxPoint result;
6681 void *argp1 = 0 ;
6682 int res1 = 0 ;
6683 PyObject *swig_obj[1] ;
6684
6685 if (!args) SWIG_fail;
6686 swig_obj[0] = args;
6687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6688 if (!SWIG_IsOK(res1)) {
6689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6690 }
6691 arg1 = reinterpret_cast< wxRect * >(argp1);
6692 {
6693 PyThreadState* __tstate = wxPyBeginAllowThreads();
6694 result = ((wxRect const *)arg1)->GetBottomRight();
6695 wxPyEndAllowThreads(__tstate);
6696 if (PyErr_Occurred()) SWIG_fail;
6697 }
6698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6706 PyObject *resultobj = 0;
6707 wxRect *arg1 = (wxRect *) 0 ;
6708 wxPoint *arg2 = 0 ;
6709 void *argp1 = 0 ;
6710 int res1 = 0 ;
6711 wxPoint temp2 ;
6712 PyObject * obj0 = 0 ;
6713 PyObject * obj1 = 0 ;
6714 char * kwnames[] = {
6715 (char *) "self",(char *) "p", NULL
6716 };
6717
6718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6720 if (!SWIG_IsOK(res1)) {
6721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6722 }
6723 arg1 = reinterpret_cast< wxRect * >(argp1);
6724 {
6725 arg2 = &temp2;
6726 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6727 }
6728 {
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_Py_Void();
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6742 PyObject *resultobj = 0;
6743 wxRect *arg1 = (wxRect *) 0 ;
6744 int result;
6745 void *argp1 = 0 ;
6746 int res1 = 0 ;
6747 PyObject *swig_obj[1] ;
6748
6749 if (!args) SWIG_fail;
6750 swig_obj[0] = args;
6751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6752 if (!SWIG_IsOK(res1)) {
6753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6754 }
6755 arg1 = reinterpret_cast< wxRect * >(argp1);
6756 {
6757 PyThreadState* __tstate = wxPyBeginAllowThreads();
6758 result = (int)((wxRect const *)arg1)->GetLeft();
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 resultobj = SWIG_From_int(static_cast< int >(result));
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6770 PyObject *resultobj = 0;
6771 wxRect *arg1 = (wxRect *) 0 ;
6772 int result;
6773 void *argp1 = 0 ;
6774 int res1 = 0 ;
6775 PyObject *swig_obj[1] ;
6776
6777 if (!args) SWIG_fail;
6778 swig_obj[0] = args;
6779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6780 if (!SWIG_IsOK(res1)) {
6781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6782 }
6783 arg1 = reinterpret_cast< wxRect * >(argp1);
6784 {
6785 PyThreadState* __tstate = wxPyBeginAllowThreads();
6786 result = (int)((wxRect const *)arg1)->GetTop();
6787 wxPyEndAllowThreads(__tstate);
6788 if (PyErr_Occurred()) SWIG_fail;
6789 }
6790 resultobj = SWIG_From_int(static_cast< int >(result));
6791 return resultobj;
6792 fail:
6793 return NULL;
6794 }
6795
6796
6797 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6798 PyObject *resultobj = 0;
6799 wxRect *arg1 = (wxRect *) 0 ;
6800 int result;
6801 void *argp1 = 0 ;
6802 int res1 = 0 ;
6803 PyObject *swig_obj[1] ;
6804
6805 if (!args) SWIG_fail;
6806 swig_obj[0] = args;
6807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6808 if (!SWIG_IsOK(res1)) {
6809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6810 }
6811 arg1 = reinterpret_cast< wxRect * >(argp1);
6812 {
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 result = (int)((wxRect const *)arg1)->GetBottom();
6815 wxPyEndAllowThreads(__tstate);
6816 if (PyErr_Occurred()) SWIG_fail;
6817 }
6818 resultobj = SWIG_From_int(static_cast< int >(result));
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6826 PyObject *resultobj = 0;
6827 wxRect *arg1 = (wxRect *) 0 ;
6828 int result;
6829 void *argp1 = 0 ;
6830 int res1 = 0 ;
6831 PyObject *swig_obj[1] ;
6832
6833 if (!args) SWIG_fail;
6834 swig_obj[0] = args;
6835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6836 if (!SWIG_IsOK(res1)) {
6837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6838 }
6839 arg1 = reinterpret_cast< wxRect * >(argp1);
6840 {
6841 PyThreadState* __tstate = wxPyBeginAllowThreads();
6842 result = (int)((wxRect const *)arg1)->GetRight();
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 resultobj = SWIG_From_int(static_cast< int >(result));
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6854 PyObject *resultobj = 0;
6855 wxRect *arg1 = (wxRect *) 0 ;
6856 int arg2 ;
6857 void *argp1 = 0 ;
6858 int res1 = 0 ;
6859 int val2 ;
6860 int ecode2 = 0 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char * kwnames[] = {
6864 (char *) "self",(char *) "left", NULL
6865 };
6866
6867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6869 if (!SWIG_IsOK(res1)) {
6870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6871 }
6872 arg1 = reinterpret_cast< wxRect * >(argp1);
6873 ecode2 = SWIG_AsVal_int(obj1, &val2);
6874 if (!SWIG_IsOK(ecode2)) {
6875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6876 }
6877 arg2 = static_cast< int >(val2);
6878 {
6879 PyThreadState* __tstate = wxPyBeginAllowThreads();
6880 (arg1)->SetLeft(arg2);
6881 wxPyEndAllowThreads(__tstate);
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 resultobj = SWIG_Py_Void();
6885 return resultobj;
6886 fail:
6887 return NULL;
6888 }
6889
6890
6891 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6892 PyObject *resultobj = 0;
6893 wxRect *arg1 = (wxRect *) 0 ;
6894 int arg2 ;
6895 void *argp1 = 0 ;
6896 int res1 = 0 ;
6897 int val2 ;
6898 int ecode2 = 0 ;
6899 PyObject * obj0 = 0 ;
6900 PyObject * obj1 = 0 ;
6901 char * kwnames[] = {
6902 (char *) "self",(char *) "right", NULL
6903 };
6904
6905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6907 if (!SWIG_IsOK(res1)) {
6908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6909 }
6910 arg1 = reinterpret_cast< wxRect * >(argp1);
6911 ecode2 = SWIG_AsVal_int(obj1, &val2);
6912 if (!SWIG_IsOK(ecode2)) {
6913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6914 }
6915 arg2 = static_cast< int >(val2);
6916 {
6917 PyThreadState* __tstate = wxPyBeginAllowThreads();
6918 (arg1)->SetRight(arg2);
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_Py_Void();
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj = 0;
6931 wxRect *arg1 = (wxRect *) 0 ;
6932 int arg2 ;
6933 void *argp1 = 0 ;
6934 int res1 = 0 ;
6935 int val2 ;
6936 int ecode2 = 0 ;
6937 PyObject * obj0 = 0 ;
6938 PyObject * obj1 = 0 ;
6939 char * kwnames[] = {
6940 (char *) "self",(char *) "top", NULL
6941 };
6942
6943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6945 if (!SWIG_IsOK(res1)) {
6946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6947 }
6948 arg1 = reinterpret_cast< wxRect * >(argp1);
6949 ecode2 = SWIG_AsVal_int(obj1, &val2);
6950 if (!SWIG_IsOK(ecode2)) {
6951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6952 }
6953 arg2 = static_cast< int >(val2);
6954 {
6955 PyThreadState* __tstate = wxPyBeginAllowThreads();
6956 (arg1)->SetTop(arg2);
6957 wxPyEndAllowThreads(__tstate);
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 resultobj = SWIG_Py_Void();
6961 return resultobj;
6962 fail:
6963 return NULL;
6964 }
6965
6966
6967 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6968 PyObject *resultobj = 0;
6969 wxRect *arg1 = (wxRect *) 0 ;
6970 int arg2 ;
6971 void *argp1 = 0 ;
6972 int res1 = 0 ;
6973 int val2 ;
6974 int ecode2 = 0 ;
6975 PyObject * obj0 = 0 ;
6976 PyObject * obj1 = 0 ;
6977 char * kwnames[] = {
6978 (char *) "self",(char *) "bottom", NULL
6979 };
6980
6981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6983 if (!SWIG_IsOK(res1)) {
6984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6985 }
6986 arg1 = reinterpret_cast< wxRect * >(argp1);
6987 ecode2 = SWIG_AsVal_int(obj1, &val2);
6988 if (!SWIG_IsOK(ecode2)) {
6989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6990 }
6991 arg2 = static_cast< int >(val2);
6992 {
6993 PyThreadState* __tstate = wxPyBeginAllowThreads();
6994 (arg1)->SetBottom(arg2);
6995 wxPyEndAllowThreads(__tstate);
6996 if (PyErr_Occurred()) SWIG_fail;
6997 }
6998 resultobj = SWIG_Py_Void();
6999 return resultobj;
7000 fail:
7001 return NULL;
7002 }
7003
7004
7005 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7006 PyObject *resultobj = 0;
7007 wxRect *arg1 = (wxRect *) 0 ;
7008 int arg2 ;
7009 int arg3 ;
7010 wxRect *result = 0 ;
7011 void *argp1 = 0 ;
7012 int res1 = 0 ;
7013 int val2 ;
7014 int ecode2 = 0 ;
7015 int val3 ;
7016 int ecode3 = 0 ;
7017 PyObject * obj0 = 0 ;
7018 PyObject * obj1 = 0 ;
7019 PyObject * obj2 = 0 ;
7020 char * kwnames[] = {
7021 (char *) "self",(char *) "dx",(char *) "dy", NULL
7022 };
7023
7024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7026 if (!SWIG_IsOK(res1)) {
7027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7028 }
7029 arg1 = reinterpret_cast< wxRect * >(argp1);
7030 ecode2 = SWIG_AsVal_int(obj1, &val2);
7031 if (!SWIG_IsOK(ecode2)) {
7032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7033 }
7034 arg2 = static_cast< int >(val2);
7035 ecode3 = SWIG_AsVal_int(obj2, &val3);
7036 if (!SWIG_IsOK(ecode3)) {
7037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7038 }
7039 arg3 = static_cast< int >(val3);
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 {
7043 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7044 result = (wxRect *) &_result_ref;
7045 }
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7050 return resultobj;
7051 fail:
7052 return NULL;
7053 }
7054
7055
7056 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7057 PyObject *resultobj = 0;
7058 wxRect *arg1 = (wxRect *) 0 ;
7059 int arg2 ;
7060 int arg3 ;
7061 wxRect *result = 0 ;
7062 void *argp1 = 0 ;
7063 int res1 = 0 ;
7064 int val2 ;
7065 int ecode2 = 0 ;
7066 int val3 ;
7067 int ecode3 = 0 ;
7068 PyObject * obj0 = 0 ;
7069 PyObject * obj1 = 0 ;
7070 PyObject * obj2 = 0 ;
7071 char * kwnames[] = {
7072 (char *) "self",(char *) "dx",(char *) "dy", NULL
7073 };
7074
7075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7077 if (!SWIG_IsOK(res1)) {
7078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7079 }
7080 arg1 = reinterpret_cast< wxRect * >(argp1);
7081 ecode2 = SWIG_AsVal_int(obj1, &val2);
7082 if (!SWIG_IsOK(ecode2)) {
7083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7084 }
7085 arg2 = static_cast< int >(val2);
7086 ecode3 = SWIG_AsVal_int(obj2, &val3);
7087 if (!SWIG_IsOK(ecode3)) {
7088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7089 }
7090 arg3 = static_cast< int >(val3);
7091 {
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 {
7094 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7095 result = (wxRect *) &_result_ref;
7096 }
7097 wxPyEndAllowThreads(__tstate);
7098 if (PyErr_Occurred()) SWIG_fail;
7099 }
7100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7101 return resultobj;
7102 fail:
7103 return NULL;
7104 }
7105
7106
7107 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7108 PyObject *resultobj = 0;
7109 wxRect *arg1 = (wxRect *) 0 ;
7110 int arg2 ;
7111 int arg3 ;
7112 void *argp1 = 0 ;
7113 int res1 = 0 ;
7114 int val2 ;
7115 int ecode2 = 0 ;
7116 int val3 ;
7117 int ecode3 = 0 ;
7118 PyObject * obj0 = 0 ;
7119 PyObject * obj1 = 0 ;
7120 PyObject * obj2 = 0 ;
7121 char * kwnames[] = {
7122 (char *) "self",(char *) "dx",(char *) "dy", NULL
7123 };
7124
7125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7127 if (!SWIG_IsOK(res1)) {
7128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7129 }
7130 arg1 = reinterpret_cast< wxRect * >(argp1);
7131 ecode2 = SWIG_AsVal_int(obj1, &val2);
7132 if (!SWIG_IsOK(ecode2)) {
7133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7134 }
7135 arg2 = static_cast< int >(val2);
7136 ecode3 = SWIG_AsVal_int(obj2, &val3);
7137 if (!SWIG_IsOK(ecode3)) {
7138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7139 }
7140 arg3 = static_cast< int >(val3);
7141 {
7142 PyThreadState* __tstate = wxPyBeginAllowThreads();
7143 (arg1)->Offset(arg2,arg3);
7144 wxPyEndAllowThreads(__tstate);
7145 if (PyErr_Occurred()) SWIG_fail;
7146 }
7147 resultobj = SWIG_Py_Void();
7148 return resultobj;
7149 fail:
7150 return NULL;
7151 }
7152
7153
7154 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7155 PyObject *resultobj = 0;
7156 wxRect *arg1 = (wxRect *) 0 ;
7157 wxPoint *arg2 = 0 ;
7158 void *argp1 = 0 ;
7159 int res1 = 0 ;
7160 wxPoint temp2 ;
7161 PyObject * obj0 = 0 ;
7162 PyObject * obj1 = 0 ;
7163 char * kwnames[] = {
7164 (char *) "self",(char *) "pt", NULL
7165 };
7166
7167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7169 if (!SWIG_IsOK(res1)) {
7170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7171 }
7172 arg1 = reinterpret_cast< wxRect * >(argp1);
7173 {
7174 arg2 = &temp2;
7175 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7176 }
7177 {
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 (arg1)->Offset((wxPoint const &)*arg2);
7180 wxPyEndAllowThreads(__tstate);
7181 if (PyErr_Occurred()) SWIG_fail;
7182 }
7183 resultobj = SWIG_Py_Void();
7184 return resultobj;
7185 fail:
7186 return NULL;
7187 }
7188
7189
7190 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7191 PyObject *resultobj = 0;
7192 wxRect *arg1 = (wxRect *) 0 ;
7193 wxRect *arg2 = 0 ;
7194 wxRect result;
7195 void *argp1 = 0 ;
7196 int res1 = 0 ;
7197 wxRect temp2 ;
7198 PyObject * obj0 = 0 ;
7199 PyObject * obj1 = 0 ;
7200 char * kwnames[] = {
7201 (char *) "self",(char *) "rect", NULL
7202 };
7203
7204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7206 if (!SWIG_IsOK(res1)) {
7207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7208 }
7209 arg1 = reinterpret_cast< wxRect * >(argp1);
7210 {
7211 arg2 = &temp2;
7212 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7213 }
7214 {
7215 PyThreadState* __tstate = wxPyBeginAllowThreads();
7216 result = (arg1)->Intersect((wxRect const &)*arg2);
7217 wxPyEndAllowThreads(__tstate);
7218 if (PyErr_Occurred()) SWIG_fail;
7219 }
7220 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj = 0;
7229 wxRect *arg1 = (wxRect *) 0 ;
7230 wxRect *arg2 = 0 ;
7231 wxRect result;
7232 void *argp1 = 0 ;
7233 int res1 = 0 ;
7234 wxRect temp2 ;
7235 PyObject * obj0 = 0 ;
7236 PyObject * obj1 = 0 ;
7237 char * kwnames[] = {
7238 (char *) "self",(char *) "rect", NULL
7239 };
7240
7241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7243 if (!SWIG_IsOK(res1)) {
7244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7245 }
7246 arg1 = reinterpret_cast< wxRect * >(argp1);
7247 {
7248 arg2 = &temp2;
7249 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7250 }
7251 {
7252 PyThreadState* __tstate = wxPyBeginAllowThreads();
7253 result = (arg1)->Union((wxRect const &)*arg2);
7254 wxPyEndAllowThreads(__tstate);
7255 if (PyErr_Occurred()) SWIG_fail;
7256 }
7257 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7258 return resultobj;
7259 fail:
7260 return NULL;
7261 }
7262
7263
7264 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7265 PyObject *resultobj = 0;
7266 wxRect *arg1 = (wxRect *) 0 ;
7267 wxRect *arg2 = 0 ;
7268 wxRect result;
7269 void *argp1 = 0 ;
7270 int res1 = 0 ;
7271 wxRect temp2 ;
7272 PyObject * obj0 = 0 ;
7273 PyObject * obj1 = 0 ;
7274 char * kwnames[] = {
7275 (char *) "self",(char *) "rect", NULL
7276 };
7277
7278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7280 if (!SWIG_IsOK(res1)) {
7281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7282 }
7283 arg1 = reinterpret_cast< wxRect * >(argp1);
7284 {
7285 arg2 = &temp2;
7286 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7287 }
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7291 wxPyEndAllowThreads(__tstate);
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7302 PyObject *resultobj = 0;
7303 wxRect *arg1 = (wxRect *) 0 ;
7304 wxRect *arg2 = 0 ;
7305 wxRect *result = 0 ;
7306 void *argp1 = 0 ;
7307 int res1 = 0 ;
7308 wxRect temp2 ;
7309 PyObject * obj0 = 0 ;
7310 PyObject * obj1 = 0 ;
7311 char * kwnames[] = {
7312 (char *) "self",(char *) "rect", NULL
7313 };
7314
7315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7317 if (!SWIG_IsOK(res1)) {
7318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7319 }
7320 arg1 = reinterpret_cast< wxRect * >(argp1);
7321 {
7322 arg2 = &temp2;
7323 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7324 }
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 {
7328 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7329 result = (wxRect *) &_result_ref;
7330 }
7331 wxPyEndAllowThreads(__tstate);
7332 if (PyErr_Occurred()) SWIG_fail;
7333 }
7334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7335 return resultobj;
7336 fail:
7337 return NULL;
7338 }
7339
7340
7341 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7342 PyObject *resultobj = 0;
7343 wxRect *arg1 = (wxRect *) 0 ;
7344 PyObject *arg2 = (PyObject *) 0 ;
7345 bool result;
7346 void *argp1 = 0 ;
7347 int res1 = 0 ;
7348 PyObject * obj0 = 0 ;
7349 PyObject * obj1 = 0 ;
7350 char * kwnames[] = {
7351 (char *) "self",(char *) "other", NULL
7352 };
7353
7354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7356 if (!SWIG_IsOK(res1)) {
7357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7358 }
7359 arg1 = reinterpret_cast< wxRect * >(argp1);
7360 arg2 = obj1;
7361 {
7362 result = (bool)wxRect___eq__(arg1,arg2);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 {
7366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7367 }
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj = 0;
7376 wxRect *arg1 = (wxRect *) 0 ;
7377 PyObject *arg2 = (PyObject *) 0 ;
7378 bool result;
7379 void *argp1 = 0 ;
7380 int res1 = 0 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 char * kwnames[] = {
7384 (char *) "self",(char *) "other", NULL
7385 };
7386
7387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7391 }
7392 arg1 = reinterpret_cast< wxRect * >(argp1);
7393 arg2 = obj1;
7394 {
7395 result = (bool)wxRect___ne__(arg1,arg2);
7396 if (PyErr_Occurred()) SWIG_fail;
7397 }
7398 {
7399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7400 }
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj = 0;
7409 wxRect *arg1 = (wxRect *) 0 ;
7410 int arg2 ;
7411 int arg3 ;
7412 bool result;
7413 void *argp1 = 0 ;
7414 int res1 = 0 ;
7415 int val2 ;
7416 int ecode2 = 0 ;
7417 int val3 ;
7418 int ecode3 = 0 ;
7419 PyObject * obj0 = 0 ;
7420 PyObject * obj1 = 0 ;
7421 PyObject * obj2 = 0 ;
7422 char * kwnames[] = {
7423 (char *) "self",(char *) "x",(char *) "y", NULL
7424 };
7425
7426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7428 if (!SWIG_IsOK(res1)) {
7429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7430 }
7431 arg1 = reinterpret_cast< wxRect * >(argp1);
7432 ecode2 = SWIG_AsVal_int(obj1, &val2);
7433 if (!SWIG_IsOK(ecode2)) {
7434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7435 }
7436 arg2 = static_cast< int >(val2);
7437 ecode3 = SWIG_AsVal_int(obj2, &val3);
7438 if (!SWIG_IsOK(ecode3)) {
7439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7440 }
7441 arg3 = static_cast< int >(val3);
7442 {
7443 PyThreadState* __tstate = wxPyBeginAllowThreads();
7444 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7445 wxPyEndAllowThreads(__tstate);
7446 if (PyErr_Occurred()) SWIG_fail;
7447 }
7448 {
7449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7450 }
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj = 0;
7459 wxRect *arg1 = (wxRect *) 0 ;
7460 wxPoint *arg2 = 0 ;
7461 bool result;
7462 void *argp1 = 0 ;
7463 int res1 = 0 ;
7464 wxPoint temp2 ;
7465 PyObject * obj0 = 0 ;
7466 PyObject * obj1 = 0 ;
7467 char * kwnames[] = {
7468 (char *) "self",(char *) "pt", NULL
7469 };
7470
7471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7473 if (!SWIG_IsOK(res1)) {
7474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7475 }
7476 arg1 = reinterpret_cast< wxRect * >(argp1);
7477 {
7478 arg2 = &temp2;
7479 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7480 }
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 {
7488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7489 }
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7497 PyObject *resultobj = 0;
7498 wxRect *arg1 = (wxRect *) 0 ;
7499 wxRect *arg2 = 0 ;
7500 bool result;
7501 void *argp1 = 0 ;
7502 int res1 = 0 ;
7503 wxRect temp2 ;
7504 PyObject * obj0 = 0 ;
7505 PyObject * obj1 = 0 ;
7506 char * kwnames[] = {
7507 (char *) "self",(char *) "rect", NULL
7508 };
7509
7510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7512 if (!SWIG_IsOK(res1)) {
7513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7514 }
7515 arg1 = reinterpret_cast< wxRect * >(argp1);
7516 {
7517 arg2 = &temp2;
7518 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7519 }
7520 {
7521 PyThreadState* __tstate = wxPyBeginAllowThreads();
7522 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 {
7527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7528 }
7529 return resultobj;
7530 fail:
7531 return NULL;
7532 }
7533
7534
7535 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7536 PyObject *resultobj = 0;
7537 wxRect *arg1 = (wxRect *) 0 ;
7538 wxRect *arg2 = 0 ;
7539 int arg3 = (int) wxBOTH ;
7540 wxRect result;
7541 void *argp1 = 0 ;
7542 int res1 = 0 ;
7543 wxRect temp2 ;
7544 int val3 ;
7545 int ecode3 = 0 ;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 PyObject * obj2 = 0 ;
7549 char * kwnames[] = {
7550 (char *) "self",(char *) "r",(char *) "dir", NULL
7551 };
7552
7553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7555 if (!SWIG_IsOK(res1)) {
7556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7557 }
7558 arg1 = reinterpret_cast< wxRect * >(argp1);
7559 {
7560 arg2 = &temp2;
7561 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7562 }
7563 if (obj2) {
7564 ecode3 = SWIG_AsVal_int(obj2, &val3);
7565 if (!SWIG_IsOK(ecode3)) {
7566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7567 }
7568 arg3 = static_cast< int >(val3);
7569 }
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7584 PyObject *resultobj = 0;
7585 wxRect *arg1 = (wxRect *) 0 ;
7586 int arg2 ;
7587 void *argp1 = 0 ;
7588 int res1 = 0 ;
7589 int val2 ;
7590 int ecode2 = 0 ;
7591 PyObject *swig_obj[2] ;
7592
7593 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7595 if (!SWIG_IsOK(res1)) {
7596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7597 }
7598 arg1 = reinterpret_cast< wxRect * >(argp1);
7599 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7600 if (!SWIG_IsOK(ecode2)) {
7601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7602 }
7603 arg2 = static_cast< int >(val2);
7604 if (arg1) (arg1)->x = arg2;
7605
7606 resultobj = SWIG_Py_Void();
7607 return resultobj;
7608 fail:
7609 return NULL;
7610 }
7611
7612
7613 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7614 PyObject *resultobj = 0;
7615 wxRect *arg1 = (wxRect *) 0 ;
7616 int result;
7617 void *argp1 = 0 ;
7618 int res1 = 0 ;
7619 PyObject *swig_obj[1] ;
7620
7621 if (!args) SWIG_fail;
7622 swig_obj[0] = args;
7623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7624 if (!SWIG_IsOK(res1)) {
7625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7626 }
7627 arg1 = reinterpret_cast< wxRect * >(argp1);
7628 result = (int) ((arg1)->x);
7629 resultobj = SWIG_From_int(static_cast< int >(result));
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7637 PyObject *resultobj = 0;
7638 wxRect *arg1 = (wxRect *) 0 ;
7639 int arg2 ;
7640 void *argp1 = 0 ;
7641 int res1 = 0 ;
7642 int val2 ;
7643 int ecode2 = 0 ;
7644 PyObject *swig_obj[2] ;
7645
7646 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7648 if (!SWIG_IsOK(res1)) {
7649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7650 }
7651 arg1 = reinterpret_cast< wxRect * >(argp1);
7652 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7653 if (!SWIG_IsOK(ecode2)) {
7654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7655 }
7656 arg2 = static_cast< int >(val2);
7657 if (arg1) (arg1)->y = arg2;
7658
7659 resultobj = SWIG_Py_Void();
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7667 PyObject *resultobj = 0;
7668 wxRect *arg1 = (wxRect *) 0 ;
7669 int result;
7670 void *argp1 = 0 ;
7671 int res1 = 0 ;
7672 PyObject *swig_obj[1] ;
7673
7674 if (!args) SWIG_fail;
7675 swig_obj[0] = args;
7676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7677 if (!SWIG_IsOK(res1)) {
7678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7679 }
7680 arg1 = reinterpret_cast< wxRect * >(argp1);
7681 result = (int) ((arg1)->y);
7682 resultobj = SWIG_From_int(static_cast< int >(result));
7683 return resultobj;
7684 fail:
7685 return NULL;
7686 }
7687
7688
7689 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7690 PyObject *resultobj = 0;
7691 wxRect *arg1 = (wxRect *) 0 ;
7692 int arg2 ;
7693 void *argp1 = 0 ;
7694 int res1 = 0 ;
7695 int val2 ;
7696 int ecode2 = 0 ;
7697 PyObject *swig_obj[2] ;
7698
7699 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7701 if (!SWIG_IsOK(res1)) {
7702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7703 }
7704 arg1 = reinterpret_cast< wxRect * >(argp1);
7705 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7706 if (!SWIG_IsOK(ecode2)) {
7707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7708 }
7709 arg2 = static_cast< int >(val2);
7710 if (arg1) (arg1)->width = arg2;
7711
7712 resultobj = SWIG_Py_Void();
7713 return resultobj;
7714 fail:
7715 return NULL;
7716 }
7717
7718
7719 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7720 PyObject *resultobj = 0;
7721 wxRect *arg1 = (wxRect *) 0 ;
7722 int result;
7723 void *argp1 = 0 ;
7724 int res1 = 0 ;
7725 PyObject *swig_obj[1] ;
7726
7727 if (!args) SWIG_fail;
7728 swig_obj[0] = args;
7729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7730 if (!SWIG_IsOK(res1)) {
7731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7732 }
7733 arg1 = reinterpret_cast< wxRect * >(argp1);
7734 result = (int) ((arg1)->width);
7735 resultobj = SWIG_From_int(static_cast< int >(result));
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7743 PyObject *resultobj = 0;
7744 wxRect *arg1 = (wxRect *) 0 ;
7745 int arg2 ;
7746 void *argp1 = 0 ;
7747 int res1 = 0 ;
7748 int val2 ;
7749 int ecode2 = 0 ;
7750 PyObject *swig_obj[2] ;
7751
7752 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7754 if (!SWIG_IsOK(res1)) {
7755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7756 }
7757 arg1 = reinterpret_cast< wxRect * >(argp1);
7758 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7759 if (!SWIG_IsOK(ecode2)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7761 }
7762 arg2 = static_cast< int >(val2);
7763 if (arg1) (arg1)->height = arg2;
7764
7765 resultobj = SWIG_Py_Void();
7766 return resultobj;
7767 fail:
7768 return NULL;
7769 }
7770
7771
7772 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7773 PyObject *resultobj = 0;
7774 wxRect *arg1 = (wxRect *) 0 ;
7775 int result;
7776 void *argp1 = 0 ;
7777 int res1 = 0 ;
7778 PyObject *swig_obj[1] ;
7779
7780 if (!args) SWIG_fail;
7781 swig_obj[0] = args;
7782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7783 if (!SWIG_IsOK(res1)) {
7784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7785 }
7786 arg1 = reinterpret_cast< wxRect * >(argp1);
7787 result = (int) ((arg1)->height);
7788 resultobj = SWIG_From_int(static_cast< int >(result));
7789 return resultobj;
7790 fail:
7791 return NULL;
7792 }
7793
7794
7795 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7796 PyObject *resultobj = 0;
7797 wxRect *arg1 = (wxRect *) 0 ;
7798 int arg2 = (int) 0 ;
7799 int arg3 = (int) 0 ;
7800 int arg4 = (int) 0 ;
7801 int arg5 = (int) 0 ;
7802 void *argp1 = 0 ;
7803 int res1 = 0 ;
7804 int val2 ;
7805 int ecode2 = 0 ;
7806 int val3 ;
7807 int ecode3 = 0 ;
7808 int val4 ;
7809 int ecode4 = 0 ;
7810 int val5 ;
7811 int ecode5 = 0 ;
7812 PyObject * obj0 = 0 ;
7813 PyObject * obj1 = 0 ;
7814 PyObject * obj2 = 0 ;
7815 PyObject * obj3 = 0 ;
7816 PyObject * obj4 = 0 ;
7817 char * kwnames[] = {
7818 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7819 };
7820
7821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7823 if (!SWIG_IsOK(res1)) {
7824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7825 }
7826 arg1 = reinterpret_cast< wxRect * >(argp1);
7827 if (obj1) {
7828 ecode2 = SWIG_AsVal_int(obj1, &val2);
7829 if (!SWIG_IsOK(ecode2)) {
7830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7831 }
7832 arg2 = static_cast< int >(val2);
7833 }
7834 if (obj2) {
7835 ecode3 = SWIG_AsVal_int(obj2, &val3);
7836 if (!SWIG_IsOK(ecode3)) {
7837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7838 }
7839 arg3 = static_cast< int >(val3);
7840 }
7841 if (obj3) {
7842 ecode4 = SWIG_AsVal_int(obj3, &val4);
7843 if (!SWIG_IsOK(ecode4)) {
7844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7845 }
7846 arg4 = static_cast< int >(val4);
7847 }
7848 if (obj4) {
7849 ecode5 = SWIG_AsVal_int(obj4, &val5);
7850 if (!SWIG_IsOK(ecode5)) {
7851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7852 }
7853 arg5 = static_cast< int >(val5);
7854 }
7855 {
7856 PyThreadState* __tstate = wxPyBeginAllowThreads();
7857 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7858 wxPyEndAllowThreads(__tstate);
7859 if (PyErr_Occurred()) SWIG_fail;
7860 }
7861 resultobj = SWIG_Py_Void();
7862 return resultobj;
7863 fail:
7864 return NULL;
7865 }
7866
7867
7868 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7869 PyObject *resultobj = 0;
7870 wxRect *arg1 = (wxRect *) 0 ;
7871 PyObject *result = 0 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 PyObject *swig_obj[1] ;
7875
7876 if (!args) SWIG_fail;
7877 swig_obj[0] = args;
7878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7879 if (!SWIG_IsOK(res1)) {
7880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7881 }
7882 arg1 = reinterpret_cast< wxRect * >(argp1);
7883 {
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 result = (PyObject *)wxRect_Get(arg1);
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 resultobj = result;
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7897 PyObject *obj;
7898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7899 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7900 return SWIG_Py_Void();
7901 }
7902
7903 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7904 return SWIG_Python_InitShadowInstance(args);
7905 }
7906
7907 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7908 PyObject *resultobj = 0;
7909 wxRect *arg1 = (wxRect *) 0 ;
7910 wxRect *arg2 = (wxRect *) 0 ;
7911 PyObject *result = 0 ;
7912 void *argp1 = 0 ;
7913 int res1 = 0 ;
7914 void *argp2 = 0 ;
7915 int res2 = 0 ;
7916 PyObject * obj0 = 0 ;
7917 PyObject * obj1 = 0 ;
7918 char * kwnames[] = {
7919 (char *) "r1",(char *) "r2", NULL
7920 };
7921
7922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7924 if (!SWIG_IsOK(res1)) {
7925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7926 }
7927 arg1 = reinterpret_cast< wxRect * >(argp1);
7928 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7929 if (!SWIG_IsOK(res2)) {
7930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7931 }
7932 arg2 = reinterpret_cast< wxRect * >(argp2);
7933 {
7934 if (!wxPyCheckForApp()) SWIG_fail;
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (PyObject *)wxIntersectRect(arg1,arg2);
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 resultobj = result;
7941 return resultobj;
7942 fail:
7943 return NULL;
7944 }
7945
7946
7947 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7948 PyObject *resultobj = 0;
7949 double arg1 = (double) 0.0 ;
7950 double arg2 = (double) 0.0 ;
7951 wxPoint2D *result = 0 ;
7952 double val1 ;
7953 int ecode1 = 0 ;
7954 double val2 ;
7955 int ecode2 = 0 ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char * kwnames[] = {
7959 (char *) "x",(char *) "y", NULL
7960 };
7961
7962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7963 if (obj0) {
7964 ecode1 = SWIG_AsVal_double(obj0, &val1);
7965 if (!SWIG_IsOK(ecode1)) {
7966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7967 }
7968 arg1 = static_cast< double >(val1);
7969 }
7970 if (obj1) {
7971 ecode2 = SWIG_AsVal_double(obj1, &val2);
7972 if (!SWIG_IsOK(ecode2)) {
7973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7974 }
7975 arg2 = static_cast< double >(val2);
7976 }
7977 {
7978 PyThreadState* __tstate = wxPyBeginAllowThreads();
7979 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7980 wxPyEndAllowThreads(__tstate);
7981 if (PyErr_Occurred()) SWIG_fail;
7982 }
7983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7984 return resultobj;
7985 fail:
7986 return NULL;
7987 }
7988
7989
7990 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7991 PyObject *resultobj = 0;
7992 wxPoint2D *arg1 = 0 ;
7993 wxPoint2D *result = 0 ;
7994 wxPoint2D temp1 ;
7995 PyObject * obj0 = 0 ;
7996 char * kwnames[] = {
7997 (char *) "pt", NULL
7998 };
7999
8000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8001 {
8002 arg1 = &temp1;
8003 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8004 }
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8012 return resultobj;
8013 fail:
8014 return NULL;
8015 }
8016
8017
8018 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8019 PyObject *resultobj = 0;
8020 wxPoint *arg1 = 0 ;
8021 wxPoint2D *result = 0 ;
8022 wxPoint temp1 ;
8023 PyObject * obj0 = 0 ;
8024 char * kwnames[] = {
8025 (char *) "pt", NULL
8026 };
8027
8028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8029 {
8030 arg1 = &temp1;
8031 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8032 }
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8036 wxPyEndAllowThreads(__tstate);
8037 if (PyErr_Occurred()) SWIG_fail;
8038 }
8039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8047 PyObject *resultobj = 0;
8048 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8049 int *arg2 = (int *) 0 ;
8050 int *arg3 = (int *) 0 ;
8051 void *argp1 = 0 ;
8052 int res1 = 0 ;
8053 int temp2 ;
8054 int res2 = SWIG_TMPOBJ ;
8055 int temp3 ;
8056 int res3 = SWIG_TMPOBJ ;
8057 PyObject *swig_obj[1] ;
8058
8059 arg2 = &temp2;
8060 arg3 = &temp3;
8061 if (!args) SWIG_fail;
8062 swig_obj[0] = args;
8063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8064 if (!SWIG_IsOK(res1)) {
8065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8066 }
8067 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8068 {
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 resultobj = SWIG_Py_Void();
8075 if (SWIG_IsTmpObj(res2)) {
8076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8077 } else {
8078 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8080 }
8081 if (SWIG_IsTmpObj(res3)) {
8082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8083 } else {
8084 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8086 }
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8094 PyObject *resultobj = 0;
8095 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8096 int *arg2 = (int *) 0 ;
8097 int *arg3 = (int *) 0 ;
8098 void *argp1 = 0 ;
8099 int res1 = 0 ;
8100 int temp2 ;
8101 int res2 = SWIG_TMPOBJ ;
8102 int temp3 ;
8103 int res3 = SWIG_TMPOBJ ;
8104 PyObject *swig_obj[1] ;
8105
8106 arg2 = &temp2;
8107 arg3 = &temp3;
8108 if (!args) SWIG_fail;
8109 swig_obj[0] = args;
8110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8111 if (!SWIG_IsOK(res1)) {
8112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8113 }
8114 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8115 {
8116 PyThreadState* __tstate = wxPyBeginAllowThreads();
8117 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8118 wxPyEndAllowThreads(__tstate);
8119 if (PyErr_Occurred()) SWIG_fail;
8120 }
8121 resultobj = SWIG_Py_Void();
8122 if (SWIG_IsTmpObj(res2)) {
8123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8124 } else {
8125 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8127 }
8128 if (SWIG_IsTmpObj(res3)) {
8129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8130 } else {
8131 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8133 }
8134 return resultobj;
8135 fail:
8136 return NULL;
8137 }
8138
8139
8140 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8141 PyObject *resultobj = 0;
8142 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8143 double result;
8144 void *argp1 = 0 ;
8145 int res1 = 0 ;
8146 PyObject *swig_obj[1] ;
8147
8148 if (!args) SWIG_fail;
8149 swig_obj[0] = args;
8150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8151 if (!SWIG_IsOK(res1)) {
8152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8153 }
8154 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8155 {
8156 PyThreadState* __tstate = wxPyBeginAllowThreads();
8157 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8158 wxPyEndAllowThreads(__tstate);
8159 if (PyErr_Occurred()) SWIG_fail;
8160 }
8161 resultobj = SWIG_From_double(static_cast< double >(result));
8162 return resultobj;
8163 fail:
8164 return NULL;
8165 }
8166
8167
8168 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8169 PyObject *resultobj = 0;
8170 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8171 double result;
8172 void *argp1 = 0 ;
8173 int res1 = 0 ;
8174 PyObject *swig_obj[1] ;
8175
8176 if (!args) SWIG_fail;
8177 swig_obj[0] = args;
8178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8179 if (!SWIG_IsOK(res1)) {
8180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8181 }
8182 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8183 {
8184 PyThreadState* __tstate = wxPyBeginAllowThreads();
8185 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 resultobj = SWIG_From_double(static_cast< double >(result));
8190 return resultobj;
8191 fail:
8192 return NULL;
8193 }
8194
8195
8196 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8197 PyObject *resultobj = 0;
8198 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8199 double arg2 ;
8200 void *argp1 = 0 ;
8201 int res1 = 0 ;
8202 double val2 ;
8203 int ecode2 = 0 ;
8204 PyObject * obj0 = 0 ;
8205 PyObject * obj1 = 0 ;
8206 char * kwnames[] = {
8207 (char *) "self",(char *) "length", NULL
8208 };
8209
8210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8212 if (!SWIG_IsOK(res1)) {
8213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8214 }
8215 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8216 ecode2 = SWIG_AsVal_double(obj1, &val2);
8217 if (!SWIG_IsOK(ecode2)) {
8218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8219 }
8220 arg2 = static_cast< double >(val2);
8221 {
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 (arg1)->SetVectorLength(arg2);
8224 wxPyEndAllowThreads(__tstate);
8225 if (PyErr_Occurred()) SWIG_fail;
8226 }
8227 resultobj = SWIG_Py_Void();
8228 return resultobj;
8229 fail:
8230 return NULL;
8231 }
8232
8233
8234 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8235 PyObject *resultobj = 0;
8236 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8237 double arg2 ;
8238 void *argp1 = 0 ;
8239 int res1 = 0 ;
8240 double val2 ;
8241 int ecode2 = 0 ;
8242 PyObject * obj0 = 0 ;
8243 PyObject * obj1 = 0 ;
8244 char * kwnames[] = {
8245 (char *) "self",(char *) "degrees", NULL
8246 };
8247
8248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8252 }
8253 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8254 ecode2 = SWIG_AsVal_double(obj1, &val2);
8255 if (!SWIG_IsOK(ecode2)) {
8256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8257 }
8258 arg2 = static_cast< double >(val2);
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 (arg1)->SetVectorAngle(arg2);
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 resultobj = SWIG_Py_Void();
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8273 PyObject *resultobj = 0;
8274 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8275 wxPoint2D *arg2 = 0 ;
8276 double result;
8277 void *argp1 = 0 ;
8278 int res1 = 0 ;
8279 wxPoint2D temp2 ;
8280 PyObject * obj0 = 0 ;
8281 PyObject * obj1 = 0 ;
8282 char * kwnames[] = {
8283 (char *) "self",(char *) "pt", NULL
8284 };
8285
8286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8288 if (!SWIG_IsOK(res1)) {
8289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8290 }
8291 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8292 {
8293 arg2 = &temp2;
8294 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8295 }
8296 {
8297 PyThreadState* __tstate = wxPyBeginAllowThreads();
8298 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 resultobj = SWIG_From_double(static_cast< double >(result));
8303 return resultobj;
8304 fail:
8305 return NULL;
8306 }
8307
8308
8309 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8310 PyObject *resultobj = 0;
8311 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8312 wxPoint2D *arg2 = 0 ;
8313 double result;
8314 void *argp1 = 0 ;
8315 int res1 = 0 ;
8316 wxPoint2D temp2 ;
8317 PyObject * obj0 = 0 ;
8318 PyObject * obj1 = 0 ;
8319 char * kwnames[] = {
8320 (char *) "self",(char *) "pt", NULL
8321 };
8322
8323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8325 if (!SWIG_IsOK(res1)) {
8326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8327 }
8328 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8329 {
8330 arg2 = &temp2;
8331 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8332 }
8333 {
8334 PyThreadState* __tstate = wxPyBeginAllowThreads();
8335 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8336 wxPyEndAllowThreads(__tstate);
8337 if (PyErr_Occurred()) SWIG_fail;
8338 }
8339 resultobj = SWIG_From_double(static_cast< double >(result));
8340 return resultobj;
8341 fail:
8342 return NULL;
8343 }
8344
8345
8346 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8347 PyObject *resultobj = 0;
8348 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8349 wxPoint2D *arg2 = 0 ;
8350 double result;
8351 void *argp1 = 0 ;
8352 int res1 = 0 ;
8353 wxPoint2D temp2 ;
8354 PyObject * obj0 = 0 ;
8355 PyObject * obj1 = 0 ;
8356 char * kwnames[] = {
8357 (char *) "self",(char *) "vec", NULL
8358 };
8359
8360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8362 if (!SWIG_IsOK(res1)) {
8363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8364 }
8365 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8366 {
8367 arg2 = &temp2;
8368 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8369 }
8370 {
8371 PyThreadState* __tstate = wxPyBeginAllowThreads();
8372 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 resultobj = SWIG_From_double(static_cast< double >(result));
8377 return resultobj;
8378 fail:
8379 return NULL;
8380 }
8381
8382
8383 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8384 PyObject *resultobj = 0;
8385 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8386 wxPoint2D *arg2 = 0 ;
8387 double result;
8388 void *argp1 = 0 ;
8389 int res1 = 0 ;
8390 wxPoint2D temp2 ;
8391 PyObject * obj0 = 0 ;
8392 PyObject * obj1 = 0 ;
8393 char * kwnames[] = {
8394 (char *) "self",(char *) "vec", NULL
8395 };
8396
8397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8399 if (!SWIG_IsOK(res1)) {
8400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8401 }
8402 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8403 {
8404 arg2 = &temp2;
8405 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8406 }
8407 {
8408 PyThreadState* __tstate = wxPyBeginAllowThreads();
8409 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8410 wxPyEndAllowThreads(__tstate);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_From_double(static_cast< double >(result));
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8421 PyObject *resultobj = 0;
8422 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8423 wxPoint2D result;
8424 void *argp1 = 0 ;
8425 int res1 = 0 ;
8426 PyObject *swig_obj[1] ;
8427
8428 if (!args) SWIG_fail;
8429 swig_obj[0] = args;
8430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8431 if (!SWIG_IsOK(res1)) {
8432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8433 }
8434 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8435 {
8436 PyThreadState* __tstate = wxPyBeginAllowThreads();
8437 result = (arg1)->operator -();
8438 wxPyEndAllowThreads(__tstate);
8439 if (PyErr_Occurred()) SWIG_fail;
8440 }
8441 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8442 return resultobj;
8443 fail:
8444 return NULL;
8445 }
8446
8447
8448 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8449 PyObject *resultobj = 0;
8450 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8451 wxPoint2D *arg2 = 0 ;
8452 wxPoint2D *result = 0 ;
8453 void *argp1 = 0 ;
8454 int res1 = 0 ;
8455 wxPoint2D temp2 ;
8456 PyObject * obj0 = 0 ;
8457 PyObject * obj1 = 0 ;
8458 char * kwnames[] = {
8459 (char *) "self",(char *) "pt", NULL
8460 };
8461
8462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8464 if (!SWIG_IsOK(res1)) {
8465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8466 }
8467 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8468 {
8469 arg2 = &temp2;
8470 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8471 }
8472 {
8473 PyThreadState* __tstate = wxPyBeginAllowThreads();
8474 {
8475 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8476 result = (wxPoint2D *) &_result_ref;
8477 }
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8489 PyObject *resultobj = 0;
8490 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8491 wxPoint2D *arg2 = 0 ;
8492 wxPoint2D *result = 0 ;
8493 void *argp1 = 0 ;
8494 int res1 = 0 ;
8495 wxPoint2D temp2 ;
8496 PyObject * obj0 = 0 ;
8497 PyObject * obj1 = 0 ;
8498 char * kwnames[] = {
8499 (char *) "self",(char *) "pt", NULL
8500 };
8501
8502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8504 if (!SWIG_IsOK(res1)) {
8505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8506 }
8507 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8508 {
8509 arg2 = &temp2;
8510 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8511 }
8512 {
8513 PyThreadState* __tstate = wxPyBeginAllowThreads();
8514 {
8515 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8516 result = (wxPoint2D *) &_result_ref;
8517 }
8518 wxPyEndAllowThreads(__tstate);
8519 if (PyErr_Occurred()) SWIG_fail;
8520 }
8521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8522 return resultobj;
8523 fail:
8524 return NULL;
8525 }
8526
8527
8528 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8529 PyObject *resultobj = 0;
8530 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8531 wxPoint2D *arg2 = 0 ;
8532 wxPoint2D *result = 0 ;
8533 void *argp1 = 0 ;
8534 int res1 = 0 ;
8535 wxPoint2D temp2 ;
8536 PyObject * obj0 = 0 ;
8537 PyObject * obj1 = 0 ;
8538 char * kwnames[] = {
8539 (char *) "self",(char *) "pt", NULL
8540 };
8541
8542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8544 if (!SWIG_IsOK(res1)) {
8545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8546 }
8547 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8548 {
8549 arg2 = &temp2;
8550 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8551 }
8552 {
8553 PyThreadState* __tstate = wxPyBeginAllowThreads();
8554 {
8555 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8556 result = (wxPoint2D *) &_result_ref;
8557 }
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8562 return resultobj;
8563 fail:
8564 return NULL;
8565 }
8566
8567
8568 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8569 PyObject *resultobj = 0;
8570 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8571 wxPoint2D *arg2 = 0 ;
8572 wxPoint2D *result = 0 ;
8573 void *argp1 = 0 ;
8574 int res1 = 0 ;
8575 wxPoint2D temp2 ;
8576 PyObject * obj0 = 0 ;
8577 PyObject * obj1 = 0 ;
8578 char * kwnames[] = {
8579 (char *) "self",(char *) "pt", NULL
8580 };
8581
8582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8584 if (!SWIG_IsOK(res1)) {
8585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8586 }
8587 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8588 {
8589 arg2 = &temp2;
8590 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8591 }
8592 {
8593 PyThreadState* __tstate = wxPyBeginAllowThreads();
8594 {
8595 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8596 result = (wxPoint2D *) &_result_ref;
8597 }
8598 wxPyEndAllowThreads(__tstate);
8599 if (PyErr_Occurred()) SWIG_fail;
8600 }
8601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8602 return resultobj;
8603 fail:
8604 return NULL;
8605 }
8606
8607
8608 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8609 PyObject *resultobj = 0;
8610 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8611 PyObject *arg2 = (PyObject *) 0 ;
8612 bool result;
8613 void *argp1 = 0 ;
8614 int res1 = 0 ;
8615 PyObject * obj0 = 0 ;
8616 PyObject * obj1 = 0 ;
8617 char * kwnames[] = {
8618 (char *) "self",(char *) "other", NULL
8619 };
8620
8621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8623 if (!SWIG_IsOK(res1)) {
8624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8625 }
8626 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8627 arg2 = obj1;
8628 {
8629 result = (bool)wxPoint2D___eq__(arg1,arg2);
8630 if (PyErr_Occurred()) SWIG_fail;
8631 }
8632 {
8633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8634 }
8635 return resultobj;
8636 fail:
8637 return NULL;
8638 }
8639
8640
8641 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj = 0;
8643 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8644 PyObject *arg2 = (PyObject *) 0 ;
8645 bool result;
8646 void *argp1 = 0 ;
8647 int res1 = 0 ;
8648 PyObject * obj0 = 0 ;
8649 PyObject * obj1 = 0 ;
8650 char * kwnames[] = {
8651 (char *) "self",(char *) "other", NULL
8652 };
8653
8654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8656 if (!SWIG_IsOK(res1)) {
8657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8658 }
8659 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8660 arg2 = obj1;
8661 {
8662 result = (bool)wxPoint2D___ne__(arg1,arg2);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 {
8666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8667 }
8668 return resultobj;
8669 fail:
8670 return NULL;
8671 }
8672
8673
8674 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8675 PyObject *resultobj = 0;
8676 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8677 double arg2 ;
8678 void *argp1 = 0 ;
8679 int res1 = 0 ;
8680 double val2 ;
8681 int ecode2 = 0 ;
8682 PyObject *swig_obj[2] ;
8683
8684 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8686 if (!SWIG_IsOK(res1)) {
8687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8688 }
8689 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8690 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8691 if (!SWIG_IsOK(ecode2)) {
8692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8693 }
8694 arg2 = static_cast< double >(val2);
8695 if (arg1) (arg1)->m_x = arg2;
8696
8697 resultobj = SWIG_Py_Void();
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8705 PyObject *resultobj = 0;
8706 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8707 double result;
8708 void *argp1 = 0 ;
8709 int res1 = 0 ;
8710 PyObject *swig_obj[1] ;
8711
8712 if (!args) SWIG_fail;
8713 swig_obj[0] = args;
8714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8715 if (!SWIG_IsOK(res1)) {
8716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8717 }
8718 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8719 result = (double) ((arg1)->m_x);
8720 resultobj = SWIG_From_double(static_cast< double >(result));
8721 return resultobj;
8722 fail:
8723 return NULL;
8724 }
8725
8726
8727 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8728 PyObject *resultobj = 0;
8729 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8730 double arg2 ;
8731 void *argp1 = 0 ;
8732 int res1 = 0 ;
8733 double val2 ;
8734 int ecode2 = 0 ;
8735 PyObject *swig_obj[2] ;
8736
8737 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8739 if (!SWIG_IsOK(res1)) {
8740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8741 }
8742 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8743 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8744 if (!SWIG_IsOK(ecode2)) {
8745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8746 }
8747 arg2 = static_cast< double >(val2);
8748 if (arg1) (arg1)->m_y = arg2;
8749
8750 resultobj = SWIG_Py_Void();
8751 return resultobj;
8752 fail:
8753 return NULL;
8754 }
8755
8756
8757 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8758 PyObject *resultobj = 0;
8759 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8760 double result;
8761 void *argp1 = 0 ;
8762 int res1 = 0 ;
8763 PyObject *swig_obj[1] ;
8764
8765 if (!args) SWIG_fail;
8766 swig_obj[0] = args;
8767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8768 if (!SWIG_IsOK(res1)) {
8769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8770 }
8771 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8772 result = (double) ((arg1)->m_y);
8773 resultobj = SWIG_From_double(static_cast< double >(result));
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
8780 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj = 0;
8782 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8783 double arg2 = (double) 0 ;
8784 double arg3 = (double) 0 ;
8785 void *argp1 = 0 ;
8786 int res1 = 0 ;
8787 double val2 ;
8788 int ecode2 = 0 ;
8789 double val3 ;
8790 int ecode3 = 0 ;
8791 PyObject * obj0 = 0 ;
8792 PyObject * obj1 = 0 ;
8793 PyObject * obj2 = 0 ;
8794 char * kwnames[] = {
8795 (char *) "self",(char *) "x",(char *) "y", NULL
8796 };
8797
8798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8800 if (!SWIG_IsOK(res1)) {
8801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8802 }
8803 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8804 if (obj1) {
8805 ecode2 = SWIG_AsVal_double(obj1, &val2);
8806 if (!SWIG_IsOK(ecode2)) {
8807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8808 }
8809 arg2 = static_cast< double >(val2);
8810 }
8811 if (obj2) {
8812 ecode3 = SWIG_AsVal_double(obj2, &val3);
8813 if (!SWIG_IsOK(ecode3)) {
8814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8815 }
8816 arg3 = static_cast< double >(val3);
8817 }
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 wxPoint2D_Set(arg1,arg2,arg3);
8821 wxPyEndAllowThreads(__tstate);
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 resultobj = SWIG_Py_Void();
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8832 PyObject *resultobj = 0;
8833 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8834 PyObject *result = 0 ;
8835 void *argp1 = 0 ;
8836 int res1 = 0 ;
8837 PyObject *swig_obj[1] ;
8838
8839 if (!args) SWIG_fail;
8840 swig_obj[0] = args;
8841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8842 if (!SWIG_IsOK(res1)) {
8843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8844 }
8845 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8846 {
8847 PyThreadState* __tstate = wxPyBeginAllowThreads();
8848 result = (PyObject *)wxPoint2D_Get(arg1);
8849 wxPyEndAllowThreads(__tstate);
8850 if (PyErr_Occurred()) SWIG_fail;
8851 }
8852 resultobj = result;
8853 return resultobj;
8854 fail:
8855 return NULL;
8856 }
8857
8858
8859 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8860 PyObject *obj;
8861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8862 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8863 return SWIG_Py_Void();
8864 }
8865
8866 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8867 return SWIG_Python_InitShadowInstance(args);
8868 }
8869
8870 SWIGINTERN int DefaultPosition_set(PyObject *) {
8871 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8872 return 1;
8873 }
8874
8875
8876 SWIGINTERN PyObject *DefaultPosition_get(void) {
8877 PyObject *pyobj = 0;
8878
8879 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8880 return pyobj;
8881 }
8882
8883
8884 SWIGINTERN int DefaultSize_set(PyObject *) {
8885 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8886 return 1;
8887 }
8888
8889
8890 SWIGINTERN PyObject *DefaultSize_get(void) {
8891 PyObject *pyobj = 0;
8892
8893 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8894 return pyobj;
8895 }
8896
8897
8898 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8899 PyObject *resultobj = 0;
8900 PyObject *arg1 = (PyObject *) 0 ;
8901 wxPyInputStream *result = 0 ;
8902 PyObject * obj0 = 0 ;
8903 char * kwnames[] = {
8904 (char *) "p", NULL
8905 };
8906
8907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8908 arg1 = obj0;
8909 {
8910 PyThreadState* __tstate = wxPyBeginAllowThreads();
8911 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8912 wxPyEndAllowThreads(__tstate);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8923 PyObject *resultobj = 0;
8924 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8925 void *argp1 = 0 ;
8926 int res1 = 0 ;
8927 PyObject *swig_obj[1] ;
8928
8929 if (!args) SWIG_fail;
8930 swig_obj[0] = args;
8931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8932 if (!SWIG_IsOK(res1)) {
8933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8934 }
8935 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 delete arg1;
8939
8940 wxPyEndAllowThreads(__tstate);
8941 if (PyErr_Occurred()) SWIG_fail;
8942 }
8943 resultobj = SWIG_Py_Void();
8944 return resultobj;
8945 fail:
8946 return NULL;
8947 }
8948
8949
8950 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951 PyObject *resultobj = 0;
8952 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8953 void *argp1 = 0 ;
8954 int res1 = 0 ;
8955 PyObject *swig_obj[1] ;
8956
8957 if (!args) SWIG_fail;
8958 swig_obj[0] = args;
8959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8960 if (!SWIG_IsOK(res1)) {
8961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8962 }
8963 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8964 {
8965 PyThreadState* __tstate = wxPyBeginAllowThreads();
8966 (arg1)->close();
8967 wxPyEndAllowThreads(__tstate);
8968 if (PyErr_Occurred()) SWIG_fail;
8969 }
8970 resultobj = SWIG_Py_Void();
8971 return resultobj;
8972 fail:
8973 return NULL;
8974 }
8975
8976
8977 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8978 PyObject *resultobj = 0;
8979 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8980 void *argp1 = 0 ;
8981 int res1 = 0 ;
8982 PyObject *swig_obj[1] ;
8983
8984 if (!args) SWIG_fail;
8985 swig_obj[0] = args;
8986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8987 if (!SWIG_IsOK(res1)) {
8988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8989 }
8990 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8991 {
8992 PyThreadState* __tstate = wxPyBeginAllowThreads();
8993 (arg1)->flush();
8994 wxPyEndAllowThreads(__tstate);
8995 if (PyErr_Occurred()) SWIG_fail;
8996 }
8997 resultobj = SWIG_Py_Void();
8998 return resultobj;
8999 fail:
9000 return NULL;
9001 }
9002
9003
9004 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9005 PyObject *resultobj = 0;
9006 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9007 bool result;
9008 void *argp1 = 0 ;
9009 int res1 = 0 ;
9010 PyObject *swig_obj[1] ;
9011
9012 if (!args) SWIG_fail;
9013 swig_obj[0] = args;
9014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9015 if (!SWIG_IsOK(res1)) {
9016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9017 }
9018 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 result = (bool)(arg1)->eof();
9022 wxPyEndAllowThreads(__tstate);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 {
9026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9027 }
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9035 PyObject *resultobj = 0;
9036 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9037 int arg2 = (int) -1 ;
9038 PyObject *result = 0 ;
9039 void *argp1 = 0 ;
9040 int res1 = 0 ;
9041 int val2 ;
9042 int ecode2 = 0 ;
9043 PyObject * obj0 = 0 ;
9044 PyObject * obj1 = 0 ;
9045 char * kwnames[] = {
9046 (char *) "self",(char *) "size", NULL
9047 };
9048
9049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9051 if (!SWIG_IsOK(res1)) {
9052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9053 }
9054 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9055 if (obj1) {
9056 ecode2 = SWIG_AsVal_int(obj1, &val2);
9057 if (!SWIG_IsOK(ecode2)) {
9058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9059 }
9060 arg2 = static_cast< int >(val2);
9061 }
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 result = (PyObject *)(arg1)->read(arg2);
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 resultobj = result;
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9076 PyObject *resultobj = 0;
9077 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9078 int arg2 = (int) -1 ;
9079 PyObject *result = 0 ;
9080 void *argp1 = 0 ;
9081 int res1 = 0 ;
9082 int val2 ;
9083 int ecode2 = 0 ;
9084 PyObject * obj0 = 0 ;
9085 PyObject * obj1 = 0 ;
9086 char * kwnames[] = {
9087 (char *) "self",(char *) "size", NULL
9088 };
9089
9090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9092 if (!SWIG_IsOK(res1)) {
9093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9094 }
9095 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9096 if (obj1) {
9097 ecode2 = SWIG_AsVal_int(obj1, &val2);
9098 if (!SWIG_IsOK(ecode2)) {
9099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9100 }
9101 arg2 = static_cast< int >(val2);
9102 }
9103 {
9104 PyThreadState* __tstate = wxPyBeginAllowThreads();
9105 result = (PyObject *)(arg1)->readline(arg2);
9106 wxPyEndAllowThreads(__tstate);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 resultobj = result;
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj = 0;
9118 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9119 int arg2 = (int) -1 ;
9120 PyObject *result = 0 ;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 int val2 ;
9124 int ecode2 = 0 ;
9125 PyObject * obj0 = 0 ;
9126 PyObject * obj1 = 0 ;
9127 char * kwnames[] = {
9128 (char *) "self",(char *) "sizehint", NULL
9129 };
9130
9131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9133 if (!SWIG_IsOK(res1)) {
9134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9135 }
9136 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9137 if (obj1) {
9138 ecode2 = SWIG_AsVal_int(obj1, &val2);
9139 if (!SWIG_IsOK(ecode2)) {
9140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9141 }
9142 arg2 = static_cast< int >(val2);
9143 }
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 result = (PyObject *)(arg1)->readlines(arg2);
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 resultobj = result;
9151 return resultobj;
9152 fail:
9153 return NULL;
9154 }
9155
9156
9157 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj = 0;
9159 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9160 int arg2 ;
9161 int arg3 = (int) 0 ;
9162 void *argp1 = 0 ;
9163 int res1 = 0 ;
9164 int val2 ;
9165 int ecode2 = 0 ;
9166 int val3 ;
9167 int ecode3 = 0 ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 PyObject * obj2 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "offset",(char *) "whence", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9181 ecode2 = SWIG_AsVal_int(obj1, &val2);
9182 if (!SWIG_IsOK(ecode2)) {
9183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9184 }
9185 arg2 = static_cast< int >(val2);
9186 if (obj2) {
9187 ecode3 = SWIG_AsVal_int(obj2, &val3);
9188 if (!SWIG_IsOK(ecode3)) {
9189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9190 }
9191 arg3 = static_cast< int >(val3);
9192 }
9193 {
9194 PyThreadState* __tstate = wxPyBeginAllowThreads();
9195 (arg1)->seek(arg2,arg3);
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 resultobj = SWIG_Py_Void();
9200 return resultobj;
9201 fail:
9202 return NULL;
9203 }
9204
9205
9206 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9207 PyObject *resultobj = 0;
9208 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9209 int result;
9210 void *argp1 = 0 ;
9211 int res1 = 0 ;
9212 PyObject *swig_obj[1] ;
9213
9214 if (!args) SWIG_fail;
9215 swig_obj[0] = args;
9216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9217 if (!SWIG_IsOK(res1)) {
9218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9219 }
9220 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9221 {
9222 PyThreadState* __tstate = wxPyBeginAllowThreads();
9223 result = (int)(arg1)->tell();
9224 wxPyEndAllowThreads(__tstate);
9225 if (PyErr_Occurred()) SWIG_fail;
9226 }
9227 resultobj = SWIG_From_int(static_cast< int >(result));
9228 return resultobj;
9229 fail:
9230 return NULL;
9231 }
9232
9233
9234 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9235 PyObject *resultobj = 0;
9236 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9237 char result;
9238 void *argp1 = 0 ;
9239 int res1 = 0 ;
9240 PyObject *swig_obj[1] ;
9241
9242 if (!args) SWIG_fail;
9243 swig_obj[0] = args;
9244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9245 if (!SWIG_IsOK(res1)) {
9246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9247 }
9248 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9249 {
9250 PyThreadState* __tstate = wxPyBeginAllowThreads();
9251 result = (char)(arg1)->Peek();
9252 wxPyEndAllowThreads(__tstate);
9253 if (PyErr_Occurred()) SWIG_fail;
9254 }
9255 resultobj = SWIG_From_char(static_cast< char >(result));
9256 return resultobj;
9257 fail:
9258 return NULL;
9259 }
9260
9261
9262 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9263 PyObject *resultobj = 0;
9264 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9265 char result;
9266 void *argp1 = 0 ;
9267 int res1 = 0 ;
9268 PyObject *swig_obj[1] ;
9269
9270 if (!args) SWIG_fail;
9271 swig_obj[0] = args;
9272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9273 if (!SWIG_IsOK(res1)) {
9274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9275 }
9276 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9277 {
9278 PyThreadState* __tstate = wxPyBeginAllowThreads();
9279 result = (char)(arg1)->GetC();
9280 wxPyEndAllowThreads(__tstate);
9281 if (PyErr_Occurred()) SWIG_fail;
9282 }
9283 resultobj = SWIG_From_char(static_cast< char >(result));
9284 return resultobj;
9285 fail:
9286 return NULL;
9287 }
9288
9289
9290 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9291 PyObject *resultobj = 0;
9292 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9293 size_t result;
9294 void *argp1 = 0 ;
9295 int res1 = 0 ;
9296 PyObject *swig_obj[1] ;
9297
9298 if (!args) SWIG_fail;
9299 swig_obj[0] = args;
9300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9301 if (!SWIG_IsOK(res1)) {
9302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9303 }
9304 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (size_t)(arg1)->LastRead();
9308 wxPyEndAllowThreads(__tstate);
9309 if (PyErr_Occurred()) SWIG_fail;
9310 }
9311 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9312 return resultobj;
9313 fail:
9314 return NULL;
9315 }
9316
9317
9318 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9319 PyObject *resultobj = 0;
9320 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9321 bool result;
9322 void *argp1 = 0 ;
9323 int res1 = 0 ;
9324 PyObject *swig_obj[1] ;
9325
9326 if (!args) SWIG_fail;
9327 swig_obj[0] = args;
9328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9329 if (!SWIG_IsOK(res1)) {
9330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9331 }
9332 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9333 {
9334 PyThreadState* __tstate = wxPyBeginAllowThreads();
9335 result = (bool)(arg1)->CanRead();
9336 wxPyEndAllowThreads(__tstate);
9337 if (PyErr_Occurred()) SWIG_fail;
9338 }
9339 {
9340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9341 }
9342 return resultobj;
9343 fail:
9344 return NULL;
9345 }
9346
9347
9348 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9349 PyObject *resultobj = 0;
9350 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9351 bool result;
9352 void *argp1 = 0 ;
9353 int res1 = 0 ;
9354 PyObject *swig_obj[1] ;
9355
9356 if (!args) SWIG_fail;
9357 swig_obj[0] = args;
9358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9359 if (!SWIG_IsOK(res1)) {
9360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9361 }
9362 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 result = (bool)(arg1)->Eof();
9366 wxPyEndAllowThreads(__tstate);
9367 if (PyErr_Occurred()) SWIG_fail;
9368 }
9369 {
9370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9371 }
9372 return resultobj;
9373 fail:
9374 return NULL;
9375 }
9376
9377
9378 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9379 PyObject *resultobj = 0;
9380 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9381 char arg2 ;
9382 bool result;
9383 void *argp1 = 0 ;
9384 int res1 = 0 ;
9385 char val2 ;
9386 int ecode2 = 0 ;
9387 PyObject * obj0 = 0 ;
9388 PyObject * obj1 = 0 ;
9389 char * kwnames[] = {
9390 (char *) "self",(char *) "c", NULL
9391 };
9392
9393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9395 if (!SWIG_IsOK(res1)) {
9396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9397 }
9398 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9399 ecode2 = SWIG_AsVal_char(obj1, &val2);
9400 if (!SWIG_IsOK(ecode2)) {
9401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9402 }
9403 arg2 = static_cast< char >(val2);
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 result = (bool)(arg1)->Ungetch(arg2);
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 {
9411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9412 }
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9420 PyObject *resultobj = 0;
9421 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9422 long arg2 ;
9423 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9424 long result;
9425 void *argp1 = 0 ;
9426 int res1 = 0 ;
9427 long val2 ;
9428 int ecode2 = 0 ;
9429 int val3 ;
9430 int ecode3 = 0 ;
9431 PyObject * obj0 = 0 ;
9432 PyObject * obj1 = 0 ;
9433 PyObject * obj2 = 0 ;
9434 char * kwnames[] = {
9435 (char *) "self",(char *) "pos",(char *) "mode", NULL
9436 };
9437
9438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9440 if (!SWIG_IsOK(res1)) {
9441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9442 }
9443 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9444 ecode2 = SWIG_AsVal_long(obj1, &val2);
9445 if (!SWIG_IsOK(ecode2)) {
9446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9447 }
9448 arg2 = static_cast< long >(val2);
9449 if (obj2) {
9450 ecode3 = SWIG_AsVal_int(obj2, &val3);
9451 if (!SWIG_IsOK(ecode3)) {
9452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9453 }
9454 arg3 = static_cast< wxSeekMode >(val3);
9455 }
9456 {
9457 PyThreadState* __tstate = wxPyBeginAllowThreads();
9458 result = (long)(arg1)->SeekI(arg2,arg3);
9459 wxPyEndAllowThreads(__tstate);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 resultobj = SWIG_From_long(static_cast< long >(result));
9463 return resultobj;
9464 fail:
9465 return NULL;
9466 }
9467
9468
9469 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9470 PyObject *resultobj = 0;
9471 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9472 long result;
9473 void *argp1 = 0 ;
9474 int res1 = 0 ;
9475 PyObject *swig_obj[1] ;
9476
9477 if (!args) SWIG_fail;
9478 swig_obj[0] = args;
9479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9480 if (!SWIG_IsOK(res1)) {
9481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9482 }
9483 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9484 {
9485 PyThreadState* __tstate = wxPyBeginAllowThreads();
9486 result = (long)(arg1)->TellI();
9487 wxPyEndAllowThreads(__tstate);
9488 if (PyErr_Occurred()) SWIG_fail;
9489 }
9490 resultobj = SWIG_From_long(static_cast< long >(result));
9491 return resultobj;
9492 fail:
9493 return NULL;
9494 }
9495
9496
9497 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9498 PyObject *obj;
9499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9500 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9501 return SWIG_Py_Void();
9502 }
9503
9504 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9505 return SWIG_Python_InitShadowInstance(args);
9506 }
9507
9508 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj = 0;
9510 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9511 PyObject *arg2 = (PyObject *) 0 ;
9512 void *argp1 = 0 ;
9513 int res1 = 0 ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 char * kwnames[] = {
9517 (char *) "self",(char *) "obj", NULL
9518 };
9519
9520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9522 if (!SWIG_IsOK(res1)) {
9523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9524 }
9525 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9526 arg2 = obj1;
9527 {
9528 PyThreadState* __tstate = wxPyBeginAllowThreads();
9529 wxOutputStream_write(arg1,arg2);
9530 wxPyEndAllowThreads(__tstate);
9531 if (PyErr_Occurred()) SWIG_fail;
9532 }
9533 resultobj = SWIG_Py_Void();
9534 return resultobj;
9535 fail:
9536 return NULL;
9537 }
9538
9539
9540 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9541 PyObject *resultobj = 0;
9542 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9543 size_t result;
9544 void *argp1 = 0 ;
9545 int res1 = 0 ;
9546 PyObject *swig_obj[1] ;
9547
9548 if (!args) SWIG_fail;
9549 swig_obj[0] = args;
9550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9551 if (!SWIG_IsOK(res1)) {
9552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9553 }
9554 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9555 {
9556 PyThreadState* __tstate = wxPyBeginAllowThreads();
9557 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9558 wxPyEndAllowThreads(__tstate);
9559 if (PyErr_Occurred()) SWIG_fail;
9560 }
9561 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9562 return resultobj;
9563 fail:
9564 return NULL;
9565 }
9566
9567
9568 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9569 PyObject *obj;
9570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9571 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9572 return SWIG_Py_Void();
9573 }
9574
9575 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9576 PyObject *resultobj = 0;
9577 wxInputStream *arg1 = (wxInputStream *) 0 ;
9578 wxString *arg2 = 0 ;
9579 wxString *arg3 = 0 ;
9580 wxString *arg4 = 0 ;
9581 wxDateTime arg5 ;
9582 wxFSFile *result = 0 ;
9583 wxPyInputStream *temp1 ;
9584 bool temp2 = false ;
9585 bool temp3 = false ;
9586 bool temp4 = false ;
9587 void *argp5 ;
9588 int res5 = 0 ;
9589 PyObject * obj0 = 0 ;
9590 PyObject * obj1 = 0 ;
9591 PyObject * obj2 = 0 ;
9592 PyObject * obj3 = 0 ;
9593 PyObject * obj4 = 0 ;
9594 char * kwnames[] = {
9595 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9596 };
9597
9598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9599 {
9600 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9601 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9602 } else {
9603 PyErr_Clear(); // clear the failure of the wxPyConvert above
9604 arg1 = wxPyCBInputStream_create(obj0, true);
9605 if (arg1 == NULL) {
9606 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9607 SWIG_fail;
9608 }
9609 }
9610 }
9611 {
9612 arg2 = wxString_in_helper(obj1);
9613 if (arg2 == NULL) SWIG_fail;
9614 temp2 = true;
9615 }
9616 {
9617 arg3 = wxString_in_helper(obj2);
9618 if (arg3 == NULL) SWIG_fail;
9619 temp3 = true;
9620 }
9621 {
9622 arg4 = wxString_in_helper(obj3);
9623 if (arg4 == NULL) SWIG_fail;
9624 temp4 = true;
9625 }
9626 {
9627 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9628 if (!SWIG_IsOK(res5)) {
9629 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9630 }
9631 if (!argp5) {
9632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9633 } else {
9634 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9635 arg5 = *temp;
9636 if (SWIG_IsNewObj(res5)) delete temp;
9637 }
9638 }
9639 {
9640 PyThreadState* __tstate = wxPyBeginAllowThreads();
9641 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9642 wxPyEndAllowThreads(__tstate);
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 {
9646 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9647 }
9648 {
9649 if (temp2)
9650 delete arg2;
9651 }
9652 {
9653 if (temp3)
9654 delete arg3;
9655 }
9656 {
9657 if (temp4)
9658 delete arg4;
9659 }
9660 return resultobj;
9661 fail:
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 NULL;
9675 }
9676
9677
9678 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9679 PyObject *resultobj = 0;
9680 wxFSFile *arg1 = (wxFSFile *) 0 ;
9681 void *argp1 = 0 ;
9682 int res1 = 0 ;
9683 PyObject *swig_obj[1] ;
9684
9685 if (!args) SWIG_fail;
9686 swig_obj[0] = args;
9687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9688 if (!SWIG_IsOK(res1)) {
9689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9690 }
9691 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9692 {
9693 PyThreadState* __tstate = wxPyBeginAllowThreads();
9694 delete arg1;
9695
9696 wxPyEndAllowThreads(__tstate);
9697 if (PyErr_Occurred()) SWIG_fail;
9698 }
9699 resultobj = SWIG_Py_Void();
9700 return resultobj;
9701 fail:
9702 return NULL;
9703 }
9704
9705
9706 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9707 PyObject *resultobj = 0;
9708 wxFSFile *arg1 = (wxFSFile *) 0 ;
9709 wxInputStream *result = 0 ;
9710 void *argp1 = 0 ;
9711 int res1 = 0 ;
9712 PyObject *swig_obj[1] ;
9713
9714 if (!args) SWIG_fail;
9715 swig_obj[0] = args;
9716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9717 if (!SWIG_IsOK(res1)) {
9718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9719 }
9720 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9721 {
9722 PyThreadState* __tstate = wxPyBeginAllowThreads();
9723 result = (wxInputStream *)(arg1)->GetStream();
9724 wxPyEndAllowThreads(__tstate);
9725 if (PyErr_Occurred()) SWIG_fail;
9726 }
9727 {
9728 wxPyInputStream * _ptr = NULL;
9729
9730 if (result) {
9731 _ptr = new wxPyInputStream(result);
9732 }
9733 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9734 }
9735 return resultobj;
9736 fail:
9737 return NULL;
9738 }
9739
9740
9741 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9742 PyObject *resultobj = 0;
9743 wxFSFile *arg1 = (wxFSFile *) 0 ;
9744 wxString *result = 0 ;
9745 void *argp1 = 0 ;
9746 int res1 = 0 ;
9747 PyObject *swig_obj[1] ;
9748
9749 if (!args) SWIG_fail;
9750 swig_obj[0] = args;
9751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9752 if (!SWIG_IsOK(res1)) {
9753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9754 }
9755 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 {
9759 wxString const &_result_ref = (arg1)->GetMimeType();
9760 result = (wxString *) &_result_ref;
9761 }
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 {
9766 #if wxUSE_UNICODE
9767 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9768 #else
9769 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9770 #endif
9771 }
9772 return resultobj;
9773 fail:
9774 return NULL;
9775 }
9776
9777
9778 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9779 PyObject *resultobj = 0;
9780 wxFSFile *arg1 = (wxFSFile *) 0 ;
9781 wxString *result = 0 ;
9782 void *argp1 = 0 ;
9783 int res1 = 0 ;
9784 PyObject *swig_obj[1] ;
9785
9786 if (!args) SWIG_fail;
9787 swig_obj[0] = args;
9788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9789 if (!SWIG_IsOK(res1)) {
9790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9791 }
9792 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9793 {
9794 PyThreadState* __tstate = wxPyBeginAllowThreads();
9795 {
9796 wxString const &_result_ref = (arg1)->GetLocation();
9797 result = (wxString *) &_result_ref;
9798 }
9799 wxPyEndAllowThreads(__tstate);
9800 if (PyErr_Occurred()) SWIG_fail;
9801 }
9802 {
9803 #if wxUSE_UNICODE
9804 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9805 #else
9806 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9807 #endif
9808 }
9809 return resultobj;
9810 fail:
9811 return NULL;
9812 }
9813
9814
9815 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9816 PyObject *resultobj = 0;
9817 wxFSFile *arg1 = (wxFSFile *) 0 ;
9818 wxString *result = 0 ;
9819 void *argp1 = 0 ;
9820 int res1 = 0 ;
9821 PyObject *swig_obj[1] ;
9822
9823 if (!args) SWIG_fail;
9824 swig_obj[0] = args;
9825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9826 if (!SWIG_IsOK(res1)) {
9827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9828 }
9829 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 {
9833 wxString const &_result_ref = (arg1)->GetAnchor();
9834 result = (wxString *) &_result_ref;
9835 }
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 {
9840 #if wxUSE_UNICODE
9841 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9842 #else
9843 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9844 #endif
9845 }
9846 return resultobj;
9847 fail:
9848 return NULL;
9849 }
9850
9851
9852 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9853 PyObject *resultobj = 0;
9854 wxFSFile *arg1 = (wxFSFile *) 0 ;
9855 wxDateTime result;
9856 void *argp1 = 0 ;
9857 int res1 = 0 ;
9858 PyObject *swig_obj[1] ;
9859
9860 if (!args) SWIG_fail;
9861 swig_obj[0] = args;
9862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9863 if (!SWIG_IsOK(res1)) {
9864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9865 }
9866 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9867 {
9868 PyThreadState* __tstate = wxPyBeginAllowThreads();
9869 result = (arg1)->GetModificationTime();
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9881 PyObject *obj;
9882 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9883 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9884 return SWIG_Py_Void();
9885 }
9886
9887 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9888 return SWIG_Python_InitShadowInstance(args);
9889 }
9890
9891 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9892 PyObject *resultobj = 0;
9893 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9894 void *argp1 = 0 ;
9895 int res1 = 0 ;
9896 PyObject *swig_obj[1] ;
9897
9898 if (!args) SWIG_fail;
9899 swig_obj[0] = args;
9900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9901 if (!SWIG_IsOK(res1)) {
9902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9903 }
9904 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 delete arg1;
9908
9909 wxPyEndAllowThreads(__tstate);
9910 if (PyErr_Occurred()) SWIG_fail;
9911 }
9912 resultobj = SWIG_Py_Void();
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9920 PyObject *obj;
9921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9922 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9923 return SWIG_Py_Void();
9924 }
9925
9926 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9927 PyObject *resultobj = 0;
9928 wxPyFileSystemHandler *result = 0 ;
9929
9930 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9938 return resultobj;
9939 fail:
9940 return NULL;
9941 }
9942
9943
9944 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9945 PyObject *resultobj = 0;
9946 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9947 PyObject *arg2 = (PyObject *) 0 ;
9948 PyObject *arg3 = (PyObject *) 0 ;
9949 void *argp1 = 0 ;
9950 int res1 = 0 ;
9951 PyObject * obj0 = 0 ;
9952 PyObject * obj1 = 0 ;
9953 PyObject * obj2 = 0 ;
9954 char * kwnames[] = {
9955 (char *) "self",(char *) "self",(char *) "_class", NULL
9956 };
9957
9958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9960 if (!SWIG_IsOK(res1)) {
9961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9962 }
9963 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9964 arg2 = obj1;
9965 arg3 = obj2;
9966 {
9967 PyThreadState* __tstate = wxPyBeginAllowThreads();
9968 (arg1)->_setCallbackInfo(arg2,arg3);
9969 wxPyEndAllowThreads(__tstate);
9970 if (PyErr_Occurred()) SWIG_fail;
9971 }
9972 resultobj = SWIG_Py_Void();
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9980 PyObject *resultobj = 0;
9981 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9982 wxString *arg2 = 0 ;
9983 bool result;
9984 void *argp1 = 0 ;
9985 int res1 = 0 ;
9986 bool temp2 = false ;
9987 PyObject * obj0 = 0 ;
9988 PyObject * obj1 = 0 ;
9989 char * kwnames[] = {
9990 (char *) "self",(char *) "location", NULL
9991 };
9992
9993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9995 if (!SWIG_IsOK(res1)) {
9996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9997 }
9998 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9999 {
10000 arg2 = wxString_in_helper(obj1);
10001 if (arg2 == NULL) SWIG_fail;
10002 temp2 = true;
10003 }
10004 {
10005 PyThreadState* __tstate = wxPyBeginAllowThreads();
10006 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10007 wxPyEndAllowThreads(__tstate);
10008 if (PyErr_Occurred()) SWIG_fail;
10009 }
10010 {
10011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10012 }
10013 {
10014 if (temp2)
10015 delete arg2;
10016 }
10017 return resultobj;
10018 fail:
10019 {
10020 if (temp2)
10021 delete arg2;
10022 }
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10028 PyObject *resultobj = 0;
10029 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10030 wxFileSystem *arg2 = 0 ;
10031 wxString *arg3 = 0 ;
10032 wxFSFile *result = 0 ;
10033 void *argp1 = 0 ;
10034 int res1 = 0 ;
10035 void *argp2 = 0 ;
10036 int res2 = 0 ;
10037 bool temp3 = false ;
10038 PyObject * obj0 = 0 ;
10039 PyObject * obj1 = 0 ;
10040 PyObject * obj2 = 0 ;
10041 char * kwnames[] = {
10042 (char *) "self",(char *) "fs",(char *) "location", NULL
10043 };
10044
10045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10047 if (!SWIG_IsOK(res1)) {
10048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10049 }
10050 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10052 if (!SWIG_IsOK(res2)) {
10053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10054 }
10055 if (!argp2) {
10056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10057 }
10058 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10059 {
10060 arg3 = wxString_in_helper(obj2);
10061 if (arg3 == NULL) SWIG_fail;
10062 temp3 = true;
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10067 wxPyEndAllowThreads(__tstate);
10068 if (PyErr_Occurred()) SWIG_fail;
10069 }
10070 {
10071 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10072 }
10073 {
10074 if (temp3)
10075 delete arg3;
10076 }
10077 return resultobj;
10078 fail:
10079 {
10080 if (temp3)
10081 delete arg3;
10082 }
10083 return NULL;
10084 }
10085
10086
10087 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj = 0;
10089 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10090 wxString *arg2 = 0 ;
10091 int arg3 = (int) 0 ;
10092 wxString result;
10093 void *argp1 = 0 ;
10094 int res1 = 0 ;
10095 bool temp2 = false ;
10096 int val3 ;
10097 int ecode3 = 0 ;
10098 PyObject * obj0 = 0 ;
10099 PyObject * obj1 = 0 ;
10100 PyObject * obj2 = 0 ;
10101 char * kwnames[] = {
10102 (char *) "self",(char *) "spec",(char *) "flags", NULL
10103 };
10104
10105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10107 if (!SWIG_IsOK(res1)) {
10108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10109 }
10110 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10111 {
10112 arg2 = wxString_in_helper(obj1);
10113 if (arg2 == NULL) SWIG_fail;
10114 temp2 = true;
10115 }
10116 if (obj2) {
10117 ecode3 = SWIG_AsVal_int(obj2, &val3);
10118 if (!SWIG_IsOK(ecode3)) {
10119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10120 }
10121 arg3 = static_cast< int >(val3);
10122 }
10123 {
10124 PyThreadState* __tstate = wxPyBeginAllowThreads();
10125 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10126 wxPyEndAllowThreads(__tstate);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 {
10130 #if wxUSE_UNICODE
10131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10132 #else
10133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10134 #endif
10135 }
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10151 PyObject *resultobj = 0;
10152 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10153 wxString result;
10154 void *argp1 = 0 ;
10155 int res1 = 0 ;
10156 PyObject *swig_obj[1] ;
10157
10158 if (!args) SWIG_fail;
10159 swig_obj[0] = args;
10160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10161 if (!SWIG_IsOK(res1)) {
10162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10163 }
10164 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10165 {
10166 PyThreadState* __tstate = wxPyBeginAllowThreads();
10167 result = (arg1)->FindNext();
10168 wxPyEndAllowThreads(__tstate);
10169 if (PyErr_Occurred()) SWIG_fail;
10170 }
10171 {
10172 #if wxUSE_UNICODE
10173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10174 #else
10175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10176 #endif
10177 }
10178 return resultobj;
10179 fail:
10180 return NULL;
10181 }
10182
10183
10184 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10185 PyObject *resultobj = 0;
10186 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10187 wxString *arg2 = 0 ;
10188 wxString result;
10189 void *argp1 = 0 ;
10190 int res1 = 0 ;
10191 bool temp2 = false ;
10192 PyObject * obj0 = 0 ;
10193 PyObject * obj1 = 0 ;
10194 char * kwnames[] = {
10195 (char *) "self",(char *) "location", NULL
10196 };
10197
10198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10200 if (!SWIG_IsOK(res1)) {
10201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10202 }
10203 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10204 {
10205 arg2 = wxString_in_helper(obj1);
10206 if (arg2 == NULL) SWIG_fail;
10207 temp2 = true;
10208 }
10209 {
10210 PyThreadState* __tstate = wxPyBeginAllowThreads();
10211 result = (arg1)->GetProtocol((wxString const &)*arg2);
10212 wxPyEndAllowThreads(__tstate);
10213 if (PyErr_Occurred()) SWIG_fail;
10214 }
10215 {
10216 #if wxUSE_UNICODE
10217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10218 #else
10219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10220 #endif
10221 }
10222 {
10223 if (temp2)
10224 delete arg2;
10225 }
10226 return resultobj;
10227 fail:
10228 {
10229 if (temp2)
10230 delete arg2;
10231 }
10232 return NULL;
10233 }
10234
10235
10236 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10237 PyObject *resultobj = 0;
10238 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10239 wxString *arg2 = 0 ;
10240 wxString result;
10241 void *argp1 = 0 ;
10242 int res1 = 0 ;
10243 bool temp2 = false ;
10244 PyObject * obj0 = 0 ;
10245 PyObject * obj1 = 0 ;
10246 char * kwnames[] = {
10247 (char *) "self",(char *) "location", NULL
10248 };
10249
10250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10252 if (!SWIG_IsOK(res1)) {
10253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10254 }
10255 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10256 {
10257 arg2 = wxString_in_helper(obj1);
10258 if (arg2 == NULL) SWIG_fail;
10259 temp2 = true;
10260 }
10261 {
10262 PyThreadState* __tstate = wxPyBeginAllowThreads();
10263 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 {
10268 #if wxUSE_UNICODE
10269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10270 #else
10271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10272 #endif
10273 }
10274 {
10275 if (temp2)
10276 delete arg2;
10277 }
10278 return resultobj;
10279 fail:
10280 {
10281 if (temp2)
10282 delete arg2;
10283 }
10284 return NULL;
10285 }
10286
10287
10288 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10289 PyObject *resultobj = 0;
10290 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10291 wxString *arg2 = 0 ;
10292 wxString result;
10293 void *argp1 = 0 ;
10294 int res1 = 0 ;
10295 bool temp2 = false ;
10296 PyObject * obj0 = 0 ;
10297 PyObject * obj1 = 0 ;
10298 char * kwnames[] = {
10299 (char *) "self",(char *) "location", NULL
10300 };
10301
10302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10304 if (!SWIG_IsOK(res1)) {
10305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10306 }
10307 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10308 {
10309 arg2 = wxString_in_helper(obj1);
10310 if (arg2 == NULL) SWIG_fail;
10311 temp2 = true;
10312 }
10313 {
10314 PyThreadState* __tstate = wxPyBeginAllowThreads();
10315 result = (arg1)->GetAnchor((wxString const &)*arg2);
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 {
10320 #if wxUSE_UNICODE
10321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10322 #else
10323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10324 #endif
10325 }
10326 {
10327 if (temp2)
10328 delete arg2;
10329 }
10330 return resultobj;
10331 fail:
10332 {
10333 if (temp2)
10334 delete arg2;
10335 }
10336 return NULL;
10337 }
10338
10339
10340 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10341 PyObject *resultobj = 0;
10342 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10343 wxString *arg2 = 0 ;
10344 wxString result;
10345 void *argp1 = 0 ;
10346 int res1 = 0 ;
10347 bool temp2 = false ;
10348 PyObject * obj0 = 0 ;
10349 PyObject * obj1 = 0 ;
10350 char * kwnames[] = {
10351 (char *) "self",(char *) "location", NULL
10352 };
10353
10354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10356 if (!SWIG_IsOK(res1)) {
10357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10358 }
10359 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10360 {
10361 arg2 = wxString_in_helper(obj1);
10362 if (arg2 == NULL) SWIG_fail;
10363 temp2 = true;
10364 }
10365 {
10366 PyThreadState* __tstate = wxPyBeginAllowThreads();
10367 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10368 wxPyEndAllowThreads(__tstate);
10369 if (PyErr_Occurred()) SWIG_fail;
10370 }
10371 {
10372 #if wxUSE_UNICODE
10373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10374 #else
10375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10376 #endif
10377 }
10378 {
10379 if (temp2)
10380 delete arg2;
10381 }
10382 return resultobj;
10383 fail:
10384 {
10385 if (temp2)
10386 delete arg2;
10387 }
10388 return NULL;
10389 }
10390
10391
10392 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10393 PyObject *resultobj = 0;
10394 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10395 wxString *arg2 = 0 ;
10396 wxString result;
10397 void *argp1 = 0 ;
10398 int res1 = 0 ;
10399 bool temp2 = false ;
10400 PyObject * obj0 = 0 ;
10401 PyObject * obj1 = 0 ;
10402 char * kwnames[] = {
10403 (char *) "self",(char *) "location", NULL
10404 };
10405
10406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10408 if (!SWIG_IsOK(res1)) {
10409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10410 }
10411 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10412 {
10413 arg2 = wxString_in_helper(obj1);
10414 if (arg2 == NULL) SWIG_fail;
10415 temp2 = true;
10416 }
10417 {
10418 PyThreadState* __tstate = wxPyBeginAllowThreads();
10419 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10420 wxPyEndAllowThreads(__tstate);
10421 if (PyErr_Occurred()) SWIG_fail;
10422 }
10423 {
10424 #if wxUSE_UNICODE
10425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10426 #else
10427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10428 #endif
10429 }
10430 {
10431 if (temp2)
10432 delete arg2;
10433 }
10434 return resultobj;
10435 fail:
10436 {
10437 if (temp2)
10438 delete arg2;
10439 }
10440 return NULL;
10441 }
10442
10443
10444 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10445 PyObject *obj;
10446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10447 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10448 return SWIG_Py_Void();
10449 }
10450
10451 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10452 return SWIG_Python_InitShadowInstance(args);
10453 }
10454
10455 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10456 PyObject *resultobj = 0;
10457 wxFileSystem *result = 0 ;
10458
10459 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10460 {
10461 PyThreadState* __tstate = wxPyBeginAllowThreads();
10462 result = (wxFileSystem *)new wxFileSystem();
10463 wxPyEndAllowThreads(__tstate);
10464 if (PyErr_Occurred()) SWIG_fail;
10465 }
10466 {
10467 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10468 }
10469 return resultobj;
10470 fail:
10471 return NULL;
10472 }
10473
10474
10475 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10476 PyObject *resultobj = 0;
10477 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10478 void *argp1 = 0 ;
10479 int res1 = 0 ;
10480 PyObject *swig_obj[1] ;
10481
10482 if (!args) SWIG_fail;
10483 swig_obj[0] = args;
10484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10485 if (!SWIG_IsOK(res1)) {
10486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10487 }
10488 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 delete arg1;
10492
10493 wxPyEndAllowThreads(__tstate);
10494 if (PyErr_Occurred()) SWIG_fail;
10495 }
10496 resultobj = SWIG_Py_Void();
10497 return resultobj;
10498 fail:
10499 return NULL;
10500 }
10501
10502
10503 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10504 PyObject *resultobj = 0;
10505 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10506 wxString *arg2 = 0 ;
10507 bool arg3 = (bool) false ;
10508 void *argp1 = 0 ;
10509 int res1 = 0 ;
10510 bool temp2 = false ;
10511 bool val3 ;
10512 int ecode3 = 0 ;
10513 PyObject * obj0 = 0 ;
10514 PyObject * obj1 = 0 ;
10515 PyObject * obj2 = 0 ;
10516 char * kwnames[] = {
10517 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10518 };
10519
10520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10522 if (!SWIG_IsOK(res1)) {
10523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10524 }
10525 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10526 {
10527 arg2 = wxString_in_helper(obj1);
10528 if (arg2 == NULL) SWIG_fail;
10529 temp2 = true;
10530 }
10531 if (obj2) {
10532 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10533 if (!SWIG_IsOK(ecode3)) {
10534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10535 }
10536 arg3 = static_cast< bool >(val3);
10537 }
10538 {
10539 PyThreadState* __tstate = wxPyBeginAllowThreads();
10540 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 resultobj = SWIG_Py_Void();
10545 {
10546 if (temp2)
10547 delete arg2;
10548 }
10549 return resultobj;
10550 fail:
10551 {
10552 if (temp2)
10553 delete arg2;
10554 }
10555 return NULL;
10556 }
10557
10558
10559 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10560 PyObject *resultobj = 0;
10561 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10562 wxString result;
10563 void *argp1 = 0 ;
10564 int res1 = 0 ;
10565 PyObject *swig_obj[1] ;
10566
10567 if (!args) SWIG_fail;
10568 swig_obj[0] = args;
10569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10570 if (!SWIG_IsOK(res1)) {
10571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10572 }
10573 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 result = (arg1)->GetPath();
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 {
10581 #if wxUSE_UNICODE
10582 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10583 #else
10584 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10585 #endif
10586 }
10587 return resultobj;
10588 fail:
10589 return NULL;
10590 }
10591
10592
10593 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10594 PyObject *resultobj = 0;
10595 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10596 wxString *arg2 = 0 ;
10597 wxFSFile *result = 0 ;
10598 void *argp1 = 0 ;
10599 int res1 = 0 ;
10600 bool temp2 = false ;
10601 PyObject * obj0 = 0 ;
10602 PyObject * obj1 = 0 ;
10603 char * kwnames[] = {
10604 (char *) "self",(char *) "location", NULL
10605 };
10606
10607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10609 if (!SWIG_IsOK(res1)) {
10610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10611 }
10612 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10613 {
10614 arg2 = wxString_in_helper(obj1);
10615 if (arg2 == NULL) SWIG_fail;
10616 temp2 = true;
10617 }
10618 {
10619 PyThreadState* __tstate = wxPyBeginAllowThreads();
10620 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10621 wxPyEndAllowThreads(__tstate);
10622 if (PyErr_Occurred()) SWIG_fail;
10623 }
10624 {
10625 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10626 }
10627 {
10628 if (temp2)
10629 delete arg2;
10630 }
10631 return resultobj;
10632 fail:
10633 {
10634 if (temp2)
10635 delete arg2;
10636 }
10637 return NULL;
10638 }
10639
10640
10641 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10642 PyObject *resultobj = 0;
10643 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10644 wxString *arg2 = 0 ;
10645 int arg3 = (int) 0 ;
10646 wxString result;
10647 void *argp1 = 0 ;
10648 int res1 = 0 ;
10649 bool temp2 = false ;
10650 int val3 ;
10651 int ecode3 = 0 ;
10652 PyObject * obj0 = 0 ;
10653 PyObject * obj1 = 0 ;
10654 PyObject * obj2 = 0 ;
10655 char * kwnames[] = {
10656 (char *) "self",(char *) "spec",(char *) "flags", NULL
10657 };
10658
10659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10661 if (!SWIG_IsOK(res1)) {
10662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10663 }
10664 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10665 {
10666 arg2 = wxString_in_helper(obj1);
10667 if (arg2 == NULL) SWIG_fail;
10668 temp2 = true;
10669 }
10670 if (obj2) {
10671 ecode3 = SWIG_AsVal_int(obj2, &val3);
10672 if (!SWIG_IsOK(ecode3)) {
10673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10674 }
10675 arg3 = static_cast< int >(val3);
10676 }
10677 {
10678 PyThreadState* __tstate = wxPyBeginAllowThreads();
10679 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 {
10684 #if wxUSE_UNICODE
10685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10686 #else
10687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10688 #endif
10689 }
10690 {
10691 if (temp2)
10692 delete arg2;
10693 }
10694 return resultobj;
10695 fail:
10696 {
10697 if (temp2)
10698 delete arg2;
10699 }
10700 return NULL;
10701 }
10702
10703
10704 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10705 PyObject *resultobj = 0;
10706 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10707 wxString result;
10708 void *argp1 = 0 ;
10709 int res1 = 0 ;
10710 PyObject *swig_obj[1] ;
10711
10712 if (!args) SWIG_fail;
10713 swig_obj[0] = args;
10714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10715 if (!SWIG_IsOK(res1)) {
10716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10717 }
10718 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10719 {
10720 PyThreadState* __tstate = wxPyBeginAllowThreads();
10721 result = (arg1)->FindNext();
10722 wxPyEndAllowThreads(__tstate);
10723 if (PyErr_Occurred()) SWIG_fail;
10724 }
10725 {
10726 #if wxUSE_UNICODE
10727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10728 #else
10729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10730 #endif
10731 }
10732 return resultobj;
10733 fail:
10734 return NULL;
10735 }
10736
10737
10738 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10739 PyObject *resultobj = 0;
10740 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10741 int res1 = 0 ;
10742 PyObject * obj0 = 0 ;
10743 char * kwnames[] = {
10744 (char *) "handler", NULL
10745 };
10746
10747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10748 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10749 if (!SWIG_IsOK(res1)) {
10750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10751 }
10752 {
10753 PyThreadState* __tstate = wxPyBeginAllowThreads();
10754 wxFileSystem::AddHandler(arg1);
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 resultobj = SWIG_Py_Void();
10759 return resultobj;
10760 fail:
10761 return NULL;
10762 }
10763
10764
10765 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10766 PyObject *resultobj = 0;
10767
10768 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 wxFileSystem::CleanUpHandlers();
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 resultobj = SWIG_Py_Void();
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10783 PyObject *resultobj = 0;
10784 wxString *arg1 = 0 ;
10785 wxString result;
10786 bool temp1 = false ;
10787 PyObject * obj0 = 0 ;
10788 char * kwnames[] = {
10789 (char *) "filename", NULL
10790 };
10791
10792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10793 {
10794 arg1 = wxString_in_helper(obj0);
10795 if (arg1 == NULL) SWIG_fail;
10796 temp1 = true;
10797 }
10798 {
10799 PyThreadState* __tstate = wxPyBeginAllowThreads();
10800 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10801 wxPyEndAllowThreads(__tstate);
10802 if (PyErr_Occurred()) SWIG_fail;
10803 }
10804 {
10805 #if wxUSE_UNICODE
10806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10807 #else
10808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10809 #endif
10810 }
10811 {
10812 if (temp1)
10813 delete arg1;
10814 }
10815 return resultobj;
10816 fail:
10817 {
10818 if (temp1)
10819 delete arg1;
10820 }
10821 return NULL;
10822 }
10823
10824
10825 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10826 PyObject *resultobj = 0;
10827 wxString *arg1 = 0 ;
10828 wxString result;
10829 bool temp1 = false ;
10830 PyObject * obj0 = 0 ;
10831 char * kwnames[] = {
10832 (char *) "url", NULL
10833 };
10834
10835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10836 {
10837 arg1 = wxString_in_helper(obj0);
10838 if (arg1 == NULL) SWIG_fail;
10839 temp1 = true;
10840 }
10841 {
10842 PyThreadState* __tstate = wxPyBeginAllowThreads();
10843 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10844 wxPyEndAllowThreads(__tstate);
10845 if (PyErr_Occurred()) SWIG_fail;
10846 }
10847 {
10848 #if wxUSE_UNICODE
10849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10850 #else
10851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10852 #endif
10853 }
10854 {
10855 if (temp1)
10856 delete arg1;
10857 }
10858 return resultobj;
10859 fail:
10860 {
10861 if (temp1)
10862 delete arg1;
10863 }
10864 return NULL;
10865 }
10866
10867
10868 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10869 PyObject *obj;
10870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10871 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10872 return SWIG_Py_Void();
10873 }
10874
10875 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10876 return SWIG_Python_InitShadowInstance(args);
10877 }
10878
10879 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10880 PyObject *resultobj = 0;
10881 wxInternetFSHandler *result = 0 ;
10882
10883 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10884 {
10885 PyThreadState* __tstate = wxPyBeginAllowThreads();
10886 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10887 wxPyEndAllowThreads(__tstate);
10888 if (PyErr_Occurred()) SWIG_fail;
10889 }
10890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10891 return resultobj;
10892 fail:
10893 return NULL;
10894 }
10895
10896
10897 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10898 PyObject *resultobj = 0;
10899 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10900 wxString *arg2 = 0 ;
10901 bool result;
10902 void *argp1 = 0 ;
10903 int res1 = 0 ;
10904 bool temp2 = false ;
10905 PyObject * obj0 = 0 ;
10906 PyObject * obj1 = 0 ;
10907 char * kwnames[] = {
10908 (char *) "self",(char *) "location", NULL
10909 };
10910
10911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10913 if (!SWIG_IsOK(res1)) {
10914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10915 }
10916 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10917 {
10918 arg2 = wxString_in_helper(obj1);
10919 if (arg2 == NULL) SWIG_fail;
10920 temp2 = true;
10921 }
10922 {
10923 PyThreadState* __tstate = wxPyBeginAllowThreads();
10924 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10925 wxPyEndAllowThreads(__tstate);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 {
10929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10930 }
10931 {
10932 if (temp2)
10933 delete arg2;
10934 }
10935 return resultobj;
10936 fail:
10937 {
10938 if (temp2)
10939 delete arg2;
10940 }
10941 return NULL;
10942 }
10943
10944
10945 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10946 PyObject *resultobj = 0;
10947 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10948 wxFileSystem *arg2 = 0 ;
10949 wxString *arg3 = 0 ;
10950 wxFSFile *result = 0 ;
10951 void *argp1 = 0 ;
10952 int res1 = 0 ;
10953 void *argp2 = 0 ;
10954 int res2 = 0 ;
10955 bool temp3 = false ;
10956 PyObject * obj0 = 0 ;
10957 PyObject * obj1 = 0 ;
10958 PyObject * obj2 = 0 ;
10959 char * kwnames[] = {
10960 (char *) "self",(char *) "fs",(char *) "location", NULL
10961 };
10962
10963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10965 if (!SWIG_IsOK(res1)) {
10966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10967 }
10968 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10970 if (!SWIG_IsOK(res2)) {
10971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10972 }
10973 if (!argp2) {
10974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10975 }
10976 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10977 {
10978 arg3 = wxString_in_helper(obj2);
10979 if (arg3 == NULL) SWIG_fail;
10980 temp3 = true;
10981 }
10982 {
10983 PyThreadState* __tstate = wxPyBeginAllowThreads();
10984 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10985 wxPyEndAllowThreads(__tstate);
10986 if (PyErr_Occurred()) SWIG_fail;
10987 }
10988 {
10989 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10990 }
10991 {
10992 if (temp3)
10993 delete arg3;
10994 }
10995 return resultobj;
10996 fail:
10997 {
10998 if (temp3)
10999 delete arg3;
11000 }
11001 return NULL;
11002 }
11003
11004
11005 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11006 PyObject *obj;
11007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11008 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11009 return SWIG_Py_Void();
11010 }
11011
11012 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11013 return SWIG_Python_InitShadowInstance(args);
11014 }
11015
11016 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11017 PyObject *resultobj = 0;
11018 wxZipFSHandler *result = 0 ;
11019
11020 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 result = (wxZipFSHandler *)new wxZipFSHandler();
11024 wxPyEndAllowThreads(__tstate);
11025 if (PyErr_Occurred()) SWIG_fail;
11026 }
11027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11028 return resultobj;
11029 fail:
11030 return NULL;
11031 }
11032
11033
11034 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11035 PyObject *resultobj = 0;
11036 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11037 wxString *arg2 = 0 ;
11038 bool result;
11039 void *argp1 = 0 ;
11040 int res1 = 0 ;
11041 bool temp2 = false ;
11042 PyObject * obj0 = 0 ;
11043 PyObject * obj1 = 0 ;
11044 char * kwnames[] = {
11045 (char *) "self",(char *) "location", NULL
11046 };
11047
11048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11050 if (!SWIG_IsOK(res1)) {
11051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11052 }
11053 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11054 {
11055 arg2 = wxString_in_helper(obj1);
11056 if (arg2 == NULL) SWIG_fail;
11057 temp2 = true;
11058 }
11059 {
11060 PyThreadState* __tstate = wxPyBeginAllowThreads();
11061 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11062 wxPyEndAllowThreads(__tstate);
11063 if (PyErr_Occurred()) SWIG_fail;
11064 }
11065 {
11066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11067 }
11068 {
11069 if (temp2)
11070 delete arg2;
11071 }
11072 return resultobj;
11073 fail:
11074 {
11075 if (temp2)
11076 delete arg2;
11077 }
11078 return NULL;
11079 }
11080
11081
11082 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11083 PyObject *resultobj = 0;
11084 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11085 wxFileSystem *arg2 = 0 ;
11086 wxString *arg3 = 0 ;
11087 wxFSFile *result = 0 ;
11088 void *argp1 = 0 ;
11089 int res1 = 0 ;
11090 void *argp2 = 0 ;
11091 int res2 = 0 ;
11092 bool temp3 = false ;
11093 PyObject * obj0 = 0 ;
11094 PyObject * obj1 = 0 ;
11095 PyObject * obj2 = 0 ;
11096 char * kwnames[] = {
11097 (char *) "self",(char *) "fs",(char *) "location", NULL
11098 };
11099
11100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11102 if (!SWIG_IsOK(res1)) {
11103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11104 }
11105 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11107 if (!SWIG_IsOK(res2)) {
11108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11109 }
11110 if (!argp2) {
11111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11112 }
11113 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11114 {
11115 arg3 = wxString_in_helper(obj2);
11116 if (arg3 == NULL) SWIG_fail;
11117 temp3 = true;
11118 }
11119 {
11120 PyThreadState* __tstate = wxPyBeginAllowThreads();
11121 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11122 wxPyEndAllowThreads(__tstate);
11123 if (PyErr_Occurred()) SWIG_fail;
11124 }
11125 {
11126 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11127 }
11128 {
11129 if (temp3)
11130 delete arg3;
11131 }
11132 return resultobj;
11133 fail:
11134 {
11135 if (temp3)
11136 delete arg3;
11137 }
11138 return NULL;
11139 }
11140
11141
11142 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11143 PyObject *resultobj = 0;
11144 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11145 wxString *arg2 = 0 ;
11146 int arg3 = (int) 0 ;
11147 wxString result;
11148 void *argp1 = 0 ;
11149 int res1 = 0 ;
11150 bool temp2 = false ;
11151 int val3 ;
11152 int ecode3 = 0 ;
11153 PyObject * obj0 = 0 ;
11154 PyObject * obj1 = 0 ;
11155 PyObject * obj2 = 0 ;
11156 char * kwnames[] = {
11157 (char *) "self",(char *) "spec",(char *) "flags", NULL
11158 };
11159
11160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11162 if (!SWIG_IsOK(res1)) {
11163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11164 }
11165 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11166 {
11167 arg2 = wxString_in_helper(obj1);
11168 if (arg2 == NULL) SWIG_fail;
11169 temp2 = true;
11170 }
11171 if (obj2) {
11172 ecode3 = SWIG_AsVal_int(obj2, &val3);
11173 if (!SWIG_IsOK(ecode3)) {
11174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11175 }
11176 arg3 = static_cast< int >(val3);
11177 }
11178 {
11179 PyThreadState* __tstate = wxPyBeginAllowThreads();
11180 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11181 wxPyEndAllowThreads(__tstate);
11182 if (PyErr_Occurred()) SWIG_fail;
11183 }
11184 {
11185 #if wxUSE_UNICODE
11186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11187 #else
11188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11189 #endif
11190 }
11191 {
11192 if (temp2)
11193 delete arg2;
11194 }
11195 return resultobj;
11196 fail:
11197 {
11198 if (temp2)
11199 delete arg2;
11200 }
11201 return NULL;
11202 }
11203
11204
11205 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11206 PyObject *resultobj = 0;
11207 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11208 wxString result;
11209 void *argp1 = 0 ;
11210 int res1 = 0 ;
11211 PyObject *swig_obj[1] ;
11212
11213 if (!args) SWIG_fail;
11214 swig_obj[0] = args;
11215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11216 if (!SWIG_IsOK(res1)) {
11217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11218 }
11219 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11220 {
11221 PyThreadState* __tstate = wxPyBeginAllowThreads();
11222 result = (arg1)->FindNext();
11223 wxPyEndAllowThreads(__tstate);
11224 if (PyErr_Occurred()) SWIG_fail;
11225 }
11226 {
11227 #if wxUSE_UNICODE
11228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11229 #else
11230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11231 #endif
11232 }
11233 return resultobj;
11234 fail:
11235 return NULL;
11236 }
11237
11238
11239 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11240 PyObject *obj;
11241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11242 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11243 return SWIG_Py_Void();
11244 }
11245
11246 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11247 return SWIG_Python_InitShadowInstance(args);
11248 }
11249
11250 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11251 PyObject *resultobj = 0;
11252 wxString *arg1 = 0 ;
11253 wxImage *arg2 = 0 ;
11254 long arg3 ;
11255 bool temp1 = false ;
11256 void *argp2 = 0 ;
11257 int res2 = 0 ;
11258 long val3 ;
11259 int ecode3 = 0 ;
11260 PyObject * obj0 = 0 ;
11261 PyObject * obj1 = 0 ;
11262 PyObject * obj2 = 0 ;
11263 char * kwnames[] = {
11264 (char *) "filename",(char *) "image",(char *) "type", NULL
11265 };
11266
11267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11268 {
11269 arg1 = wxString_in_helper(obj0);
11270 if (arg1 == NULL) SWIG_fail;
11271 temp1 = true;
11272 }
11273 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11274 if (!SWIG_IsOK(res2)) {
11275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11276 }
11277 if (!argp2) {
11278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11279 }
11280 arg2 = reinterpret_cast< wxImage * >(argp2);
11281 ecode3 = SWIG_AsVal_long(obj2, &val3);
11282 if (!SWIG_IsOK(ecode3)) {
11283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11284 }
11285 arg3 = static_cast< long >(val3);
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 resultobj = SWIG_Py_Void();
11293 {
11294 if (temp1)
11295 delete arg1;
11296 }
11297 return resultobj;
11298 fail:
11299 {
11300 if (temp1)
11301 delete arg1;
11302 }
11303 return NULL;
11304 }
11305
11306
11307 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11308 PyObject *resultobj = 0;
11309 wxString *arg1 = 0 ;
11310 wxBitmap *arg2 = 0 ;
11311 long arg3 ;
11312 bool temp1 = false ;
11313 void *argp2 = 0 ;
11314 int res2 = 0 ;
11315 long val3 ;
11316 int ecode3 = 0 ;
11317 PyObject * obj0 = 0 ;
11318 PyObject * obj1 = 0 ;
11319 PyObject * obj2 = 0 ;
11320 char * kwnames[] = {
11321 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11322 };
11323
11324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11325 {
11326 arg1 = wxString_in_helper(obj0);
11327 if (arg1 == NULL) SWIG_fail;
11328 temp1 = true;
11329 }
11330 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11331 if (!SWIG_IsOK(res2)) {
11332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11333 }
11334 if (!argp2) {
11335 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11336 }
11337 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11338 ecode3 = SWIG_AsVal_long(obj2, &val3);
11339 if (!SWIG_IsOK(ecode3)) {
11340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11341 }
11342 arg3 = static_cast< long >(val3);
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 resultobj = SWIG_Py_Void();
11350 {
11351 if (temp1)
11352 delete arg1;
11353 }
11354 return resultobj;
11355 fail:
11356 {
11357 if (temp1)
11358 delete arg1;
11359 }
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11365 PyObject *resultobj = 0;
11366 wxString *arg1 = 0 ;
11367 PyObject *arg2 = (PyObject *) 0 ;
11368 bool temp1 = false ;
11369 PyObject * obj0 = 0 ;
11370 PyObject * obj1 = 0 ;
11371 char * kwnames[] = {
11372 (char *) "filename",(char *) "data", NULL
11373 };
11374
11375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11376 {
11377 arg1 = wxString_in_helper(obj0);
11378 if (arg1 == NULL) SWIG_fail;
11379 temp1 = true;
11380 }
11381 arg2 = obj1;
11382 {
11383 PyThreadState* __tstate = wxPyBeginAllowThreads();
11384 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11385 wxPyEndAllowThreads(__tstate);
11386 if (PyErr_Occurred()) SWIG_fail;
11387 }
11388 resultobj = SWIG_Py_Void();
11389 {
11390 if (temp1)
11391 delete arg1;
11392 }
11393 return resultobj;
11394 fail:
11395 {
11396 if (temp1)
11397 delete arg1;
11398 }
11399 return NULL;
11400 }
11401
11402
11403 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11404 PyObject *resultobj = 0;
11405 wxMemoryFSHandler *result = 0 ;
11406
11407 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11408 {
11409 PyThreadState* __tstate = wxPyBeginAllowThreads();
11410 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11411 wxPyEndAllowThreads(__tstate);
11412 if (PyErr_Occurred()) SWIG_fail;
11413 }
11414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11415 return resultobj;
11416 fail:
11417 return NULL;
11418 }
11419
11420
11421 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11422 PyObject *resultobj = 0;
11423 wxString *arg1 = 0 ;
11424 bool temp1 = false ;
11425 PyObject * obj0 = 0 ;
11426 char * kwnames[] = {
11427 (char *) "filename", NULL
11428 };
11429
11430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11431 {
11432 arg1 = wxString_in_helper(obj0);
11433 if (arg1 == NULL) SWIG_fail;
11434 temp1 = true;
11435 }
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11439 wxPyEndAllowThreads(__tstate);
11440 if (PyErr_Occurred()) SWIG_fail;
11441 }
11442 resultobj = SWIG_Py_Void();
11443 {
11444 if (temp1)
11445 delete arg1;
11446 }
11447 return resultobj;
11448 fail:
11449 {
11450 if (temp1)
11451 delete arg1;
11452 }
11453 return NULL;
11454 }
11455
11456
11457 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11458 PyObject *resultobj = 0;
11459 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11460 wxString *arg2 = 0 ;
11461 bool result;
11462 void *argp1 = 0 ;
11463 int res1 = 0 ;
11464 bool temp2 = false ;
11465 PyObject * obj0 = 0 ;
11466 PyObject * obj1 = 0 ;
11467 char * kwnames[] = {
11468 (char *) "self",(char *) "location", NULL
11469 };
11470
11471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11473 if (!SWIG_IsOK(res1)) {
11474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11475 }
11476 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11477 {
11478 arg2 = wxString_in_helper(obj1);
11479 if (arg2 == NULL) SWIG_fail;
11480 temp2 = true;
11481 }
11482 {
11483 PyThreadState* __tstate = wxPyBeginAllowThreads();
11484 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11485 wxPyEndAllowThreads(__tstate);
11486 if (PyErr_Occurred()) SWIG_fail;
11487 }
11488 {
11489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11490 }
11491 {
11492 if (temp2)
11493 delete arg2;
11494 }
11495 return resultobj;
11496 fail:
11497 {
11498 if (temp2)
11499 delete arg2;
11500 }
11501 return NULL;
11502 }
11503
11504
11505 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11506 PyObject *resultobj = 0;
11507 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11508 wxFileSystem *arg2 = 0 ;
11509 wxString *arg3 = 0 ;
11510 wxFSFile *result = 0 ;
11511 void *argp1 = 0 ;
11512 int res1 = 0 ;
11513 void *argp2 = 0 ;
11514 int res2 = 0 ;
11515 bool temp3 = false ;
11516 PyObject * obj0 = 0 ;
11517 PyObject * obj1 = 0 ;
11518 PyObject * obj2 = 0 ;
11519 char * kwnames[] = {
11520 (char *) "self",(char *) "fs",(char *) "location", NULL
11521 };
11522
11523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11525 if (!SWIG_IsOK(res1)) {
11526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11527 }
11528 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11529 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11530 if (!SWIG_IsOK(res2)) {
11531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11532 }
11533 if (!argp2) {
11534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11535 }
11536 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11537 {
11538 arg3 = wxString_in_helper(obj2);
11539 if (arg3 == NULL) SWIG_fail;
11540 temp3 = true;
11541 }
11542 {
11543 PyThreadState* __tstate = wxPyBeginAllowThreads();
11544 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 {
11549 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11550 }
11551 {
11552 if (temp3)
11553 delete arg3;
11554 }
11555 return resultobj;
11556 fail:
11557 {
11558 if (temp3)
11559 delete arg3;
11560 }
11561 return NULL;
11562 }
11563
11564
11565 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj = 0;
11567 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11568 wxString *arg2 = 0 ;
11569 int arg3 = (int) 0 ;
11570 wxString result;
11571 void *argp1 = 0 ;
11572 int res1 = 0 ;
11573 bool temp2 = false ;
11574 int val3 ;
11575 int ecode3 = 0 ;
11576 PyObject * obj0 = 0 ;
11577 PyObject * obj1 = 0 ;
11578 PyObject * obj2 = 0 ;
11579 char * kwnames[] = {
11580 (char *) "self",(char *) "spec",(char *) "flags", NULL
11581 };
11582
11583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11585 if (!SWIG_IsOK(res1)) {
11586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11587 }
11588 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11589 {
11590 arg2 = wxString_in_helper(obj1);
11591 if (arg2 == NULL) SWIG_fail;
11592 temp2 = true;
11593 }
11594 if (obj2) {
11595 ecode3 = SWIG_AsVal_int(obj2, &val3);
11596 if (!SWIG_IsOK(ecode3)) {
11597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11598 }
11599 arg3 = static_cast< int >(val3);
11600 }
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11604 wxPyEndAllowThreads(__tstate);
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 {
11608 #if wxUSE_UNICODE
11609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11610 #else
11611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11612 #endif
11613 }
11614 {
11615 if (temp2)
11616 delete arg2;
11617 }
11618 return resultobj;
11619 fail:
11620 {
11621 if (temp2)
11622 delete arg2;
11623 }
11624 return NULL;
11625 }
11626
11627
11628 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11629 PyObject *resultobj = 0;
11630 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11631 wxString result;
11632 void *argp1 = 0 ;
11633 int res1 = 0 ;
11634 PyObject *swig_obj[1] ;
11635
11636 if (!args) SWIG_fail;
11637 swig_obj[0] = args;
11638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11639 if (!SWIG_IsOK(res1)) {
11640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11641 }
11642 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11643 {
11644 PyThreadState* __tstate = wxPyBeginAllowThreads();
11645 result = (arg1)->FindNext();
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 {
11650 #if wxUSE_UNICODE
11651 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11652 #else
11653 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11654 #endif
11655 }
11656 return resultobj;
11657 fail:
11658 return NULL;
11659 }
11660
11661
11662 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11663 PyObject *obj;
11664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11665 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11666 return SWIG_Py_Void();
11667 }
11668
11669 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11670 return SWIG_Python_InitShadowInstance(args);
11671 }
11672
11673 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11674 PyObject *resultobj = 0;
11675 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11676 wxString result;
11677 void *argp1 = 0 ;
11678 int res1 = 0 ;
11679 PyObject *swig_obj[1] ;
11680
11681 if (!args) SWIG_fail;
11682 swig_obj[0] = args;
11683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11684 if (!SWIG_IsOK(res1)) {
11685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11686 }
11687 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11688 {
11689 PyThreadState* __tstate = wxPyBeginAllowThreads();
11690 result = (arg1)->GetName();
11691 wxPyEndAllowThreads(__tstate);
11692 if (PyErr_Occurred()) SWIG_fail;
11693 }
11694 {
11695 #if wxUSE_UNICODE
11696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11697 #else
11698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11699 #endif
11700 }
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11708 PyObject *resultobj = 0;
11709 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11710 wxString result;
11711 void *argp1 = 0 ;
11712 int res1 = 0 ;
11713 PyObject *swig_obj[1] ;
11714
11715 if (!args) SWIG_fail;
11716 swig_obj[0] = args;
11717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11718 if (!SWIG_IsOK(res1)) {
11719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11720 }
11721 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11722 {
11723 PyThreadState* __tstate = wxPyBeginAllowThreads();
11724 result = (arg1)->GetExtension();
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 {
11729 #if wxUSE_UNICODE
11730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11731 #else
11732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11733 #endif
11734 }
11735 return resultobj;
11736 fail:
11737 return NULL;
11738 }
11739
11740
11741 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11742 PyObject *resultobj = 0;
11743 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11744 long result;
11745 void *argp1 = 0 ;
11746 int res1 = 0 ;
11747 PyObject *swig_obj[1] ;
11748
11749 if (!args) SWIG_fail;
11750 swig_obj[0] = args;
11751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11752 if (!SWIG_IsOK(res1)) {
11753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11754 }
11755 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (long)(arg1)->GetType();
11759 wxPyEndAllowThreads(__tstate);
11760 if (PyErr_Occurred()) SWIG_fail;
11761 }
11762 resultobj = SWIG_From_long(static_cast< long >(result));
11763 return resultobj;
11764 fail:
11765 return NULL;
11766 }
11767
11768
11769 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11770 PyObject *resultobj = 0;
11771 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11772 wxString result;
11773 void *argp1 = 0 ;
11774 int res1 = 0 ;
11775 PyObject *swig_obj[1] ;
11776
11777 if (!args) SWIG_fail;
11778 swig_obj[0] = args;
11779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11780 if (!SWIG_IsOK(res1)) {
11781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11782 }
11783 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 result = (arg1)->GetMimeType();
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 #if wxUSE_UNICODE
11792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11793 #else
11794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11795 #endif
11796 }
11797 return resultobj;
11798 fail:
11799 return NULL;
11800 }
11801
11802
11803 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11804 PyObject *resultobj = 0;
11805 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11806 wxString *arg2 = 0 ;
11807 bool result;
11808 void *argp1 = 0 ;
11809 int res1 = 0 ;
11810 bool temp2 = false ;
11811 PyObject * obj0 = 0 ;
11812 PyObject * obj1 = 0 ;
11813 char * kwnames[] = {
11814 (char *) "self",(char *) "name", NULL
11815 };
11816
11817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11819 if (!SWIG_IsOK(res1)) {
11820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11821 }
11822 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11823 {
11824 arg2 = wxString_in_helper(obj1);
11825 if (arg2 == NULL) SWIG_fail;
11826 temp2 = true;
11827 }
11828 {
11829 PyThreadState* __tstate = wxPyBeginAllowThreads();
11830 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11831 wxPyEndAllowThreads(__tstate);
11832 if (PyErr_Occurred()) SWIG_fail;
11833 }
11834 {
11835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11836 }
11837 {
11838 if (temp2)
11839 delete arg2;
11840 }
11841 return resultobj;
11842 fail:
11843 {
11844 if (temp2)
11845 delete arg2;
11846 }
11847 return NULL;
11848 }
11849
11850
11851 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11852 PyObject *resultobj = 0;
11853 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11854 wxString *arg2 = 0 ;
11855 void *argp1 = 0 ;
11856 int res1 = 0 ;
11857 bool temp2 = false ;
11858 PyObject * obj0 = 0 ;
11859 PyObject * obj1 = 0 ;
11860 char * kwnames[] = {
11861 (char *) "self",(char *) "name", NULL
11862 };
11863
11864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11866 if (!SWIG_IsOK(res1)) {
11867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11868 }
11869 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11870 {
11871 arg2 = wxString_in_helper(obj1);
11872 if (arg2 == NULL) SWIG_fail;
11873 temp2 = true;
11874 }
11875 {
11876 PyThreadState* __tstate = wxPyBeginAllowThreads();
11877 (arg1)->SetName((wxString const &)*arg2);
11878 wxPyEndAllowThreads(__tstate);
11879 if (PyErr_Occurred()) SWIG_fail;
11880 }
11881 resultobj = SWIG_Py_Void();
11882 {
11883 if (temp2)
11884 delete arg2;
11885 }
11886 return resultobj;
11887 fail:
11888 {
11889 if (temp2)
11890 delete arg2;
11891 }
11892 return NULL;
11893 }
11894
11895
11896 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11897 PyObject *resultobj = 0;
11898 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11899 wxString *arg2 = 0 ;
11900 void *argp1 = 0 ;
11901 int res1 = 0 ;
11902 bool temp2 = false ;
11903 PyObject * obj0 = 0 ;
11904 PyObject * obj1 = 0 ;
11905 char * kwnames[] = {
11906 (char *) "self",(char *) "extension", NULL
11907 };
11908
11909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11911 if (!SWIG_IsOK(res1)) {
11912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11913 }
11914 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11915 {
11916 arg2 = wxString_in_helper(obj1);
11917 if (arg2 == NULL) SWIG_fail;
11918 temp2 = true;
11919 }
11920 {
11921 PyThreadState* __tstate = wxPyBeginAllowThreads();
11922 (arg1)->SetExtension((wxString const &)*arg2);
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 resultobj = SWIG_Py_Void();
11927 {
11928 if (temp2)
11929 delete arg2;
11930 }
11931 return resultobj;
11932 fail:
11933 {
11934 if (temp2)
11935 delete arg2;
11936 }
11937 return NULL;
11938 }
11939
11940
11941 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11942 PyObject *resultobj = 0;
11943 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11944 long arg2 ;
11945 void *argp1 = 0 ;
11946 int res1 = 0 ;
11947 long val2 ;
11948 int ecode2 = 0 ;
11949 PyObject * obj0 = 0 ;
11950 PyObject * obj1 = 0 ;
11951 char * kwnames[] = {
11952 (char *) "self",(char *) "type", NULL
11953 };
11954
11955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11957 if (!SWIG_IsOK(res1)) {
11958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11959 }
11960 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11961 ecode2 = SWIG_AsVal_long(obj1, &val2);
11962 if (!SWIG_IsOK(ecode2)) {
11963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11964 }
11965 arg2 = static_cast< long >(val2);
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 (arg1)->SetType(arg2);
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 resultobj = SWIG_Py_Void();
11973 return resultobj;
11974 fail:
11975 return NULL;
11976 }
11977
11978
11979 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11980 PyObject *resultobj = 0;
11981 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11982 wxString *arg2 = 0 ;
11983 void *argp1 = 0 ;
11984 int res1 = 0 ;
11985 bool temp2 = false ;
11986 PyObject * obj0 = 0 ;
11987 PyObject * obj1 = 0 ;
11988 char * kwnames[] = {
11989 (char *) "self",(char *) "mimetype", NULL
11990 };
11991
11992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11994 if (!SWIG_IsOK(res1)) {
11995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11996 }
11997 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11998 {
11999 arg2 = wxString_in_helper(obj1);
12000 if (arg2 == NULL) SWIG_fail;
12001 temp2 = true;
12002 }
12003 {
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 (arg1)->SetMimeType((wxString const &)*arg2);
12006 wxPyEndAllowThreads(__tstate);
12007 if (PyErr_Occurred()) SWIG_fail;
12008 }
12009 resultobj = SWIG_Py_Void();
12010 {
12011 if (temp2)
12012 delete arg2;
12013 }
12014 return resultobj;
12015 fail:
12016 {
12017 if (temp2)
12018 delete arg2;
12019 }
12020 return NULL;
12021 }
12022
12023
12024 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12025 PyObject *obj;
12026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12027 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12028 return SWIG_Py_Void();
12029 }
12030
12031 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12032 PyObject *resultobj = 0;
12033 wxPyImageHandler *result = 0 ;
12034
12035 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12036 {
12037 PyThreadState* __tstate = wxPyBeginAllowThreads();
12038 result = (wxPyImageHandler *)new wxPyImageHandler();
12039 wxPyEndAllowThreads(__tstate);
12040 if (PyErr_Occurred()) SWIG_fail;
12041 }
12042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj = 0;
12051 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12052 PyObject *arg2 = (PyObject *) 0 ;
12053 void *argp1 = 0 ;
12054 int res1 = 0 ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 char * kwnames[] = {
12058 (char *) "self",(char *) "self", NULL
12059 };
12060
12061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12063 if (!SWIG_IsOK(res1)) {
12064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12065 }
12066 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12067 arg2 = obj1;
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 (arg1)->_SetSelf(arg2);
12071 wxPyEndAllowThreads(__tstate);
12072 if (PyErr_Occurred()) SWIG_fail;
12073 }
12074 resultobj = SWIG_Py_Void();
12075 return resultobj;
12076 fail:
12077 return NULL;
12078 }
12079
12080
12081 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12082 PyObject *obj;
12083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12084 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12085 return SWIG_Py_Void();
12086 }
12087
12088 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12089 return SWIG_Python_InitShadowInstance(args);
12090 }
12091
12092 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12093 PyObject *resultobj = 0;
12094 wxImageHistogram *result = 0 ;
12095
12096 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 result = (wxImageHistogram *)new wxImageHistogram();
12100 wxPyEndAllowThreads(__tstate);
12101 if (PyErr_Occurred()) SWIG_fail;
12102 }
12103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12104 return resultobj;
12105 fail:
12106 return NULL;
12107 }
12108
12109
12110 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12111 PyObject *resultobj = 0;
12112 byte arg1 ;
12113 byte arg2 ;
12114 byte arg3 ;
12115 unsigned long result;
12116 unsigned char val1 ;
12117 int ecode1 = 0 ;
12118 unsigned char val2 ;
12119 int ecode2 = 0 ;
12120 unsigned char val3 ;
12121 int ecode3 = 0 ;
12122 PyObject * obj0 = 0 ;
12123 PyObject * obj1 = 0 ;
12124 PyObject * obj2 = 0 ;
12125 char * kwnames[] = {
12126 (char *) "r",(char *) "g",(char *) "b", NULL
12127 };
12128
12129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12130 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12131 if (!SWIG_IsOK(ecode1)) {
12132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12133 }
12134 arg1 = static_cast< byte >(val1);
12135 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12136 if (!SWIG_IsOK(ecode2)) {
12137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12138 }
12139 arg2 = static_cast< byte >(val2);
12140 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12141 if (!SWIG_IsOK(ecode3)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12143 }
12144 arg3 = static_cast< byte >(val3);
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12159 PyObject *resultobj = 0;
12160 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12161 byte *arg2 = (byte *) 0 ;
12162 byte *arg3 = (byte *) 0 ;
12163 byte *arg4 = (byte *) 0 ;
12164 byte arg5 = (byte) 1 ;
12165 byte arg6 = (byte) 0 ;
12166 byte arg7 = (byte) 0 ;
12167 bool result;
12168 void *argp1 = 0 ;
12169 int res1 = 0 ;
12170 byte temp2 ;
12171 int res2 = SWIG_TMPOBJ ;
12172 byte temp3 ;
12173 int res3 = SWIG_TMPOBJ ;
12174 byte temp4 ;
12175 int res4 = SWIG_TMPOBJ ;
12176 unsigned char val5 ;
12177 int ecode5 = 0 ;
12178 unsigned char val6 ;
12179 int ecode6 = 0 ;
12180 unsigned char val7 ;
12181 int ecode7 = 0 ;
12182 PyObject * obj0 = 0 ;
12183 PyObject * obj1 = 0 ;
12184 PyObject * obj2 = 0 ;
12185 PyObject * obj3 = 0 ;
12186 char * kwnames[] = {
12187 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12188 };
12189
12190 arg2 = &temp2;
12191 arg3 = &temp3;
12192 arg4 = &temp4;
12193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12195 if (!SWIG_IsOK(res1)) {
12196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12197 }
12198 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12199 if (obj1) {
12200 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12201 if (!SWIG_IsOK(ecode5)) {
12202 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12203 }
12204 arg5 = static_cast< byte >(val5);
12205 }
12206 if (obj2) {
12207 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12208 if (!SWIG_IsOK(ecode6)) {
12209 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12210 }
12211 arg6 = static_cast< byte >(val6);
12212 }
12213 if (obj3) {
12214 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12215 if (!SWIG_IsOK(ecode7)) {
12216 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12217 }
12218 arg7 = static_cast< byte >(val7);
12219 }
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12223 wxPyEndAllowThreads(__tstate);
12224 if (PyErr_Occurred()) SWIG_fail;
12225 }
12226 {
12227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12228 }
12229 if (SWIG_IsTmpObj(res2)) {
12230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12231 } else {
12232 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12234 }
12235 if (SWIG_IsTmpObj(res3)) {
12236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12237 } else {
12238 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12240 }
12241 if (SWIG_IsTmpObj(res4)) {
12242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12243 } else {
12244 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12245 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12246 }
12247 return resultobj;
12248 fail:
12249 return NULL;
12250 }
12251
12252
12253 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12254 PyObject *resultobj = 0;
12255 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12256 unsigned long arg2 ;
12257 unsigned long result;
12258 void *argp1 = 0 ;
12259 int res1 = 0 ;
12260 unsigned long val2 ;
12261 int ecode2 = 0 ;
12262 PyObject * obj0 = 0 ;
12263 PyObject * obj1 = 0 ;
12264 char * kwnames[] = {
12265 (char *) "self",(char *) "key", NULL
12266 };
12267
12268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12270 if (!SWIG_IsOK(res1)) {
12271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12272 }
12273 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12274 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12275 if (!SWIG_IsOK(ecode2)) {
12276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12277 }
12278 arg2 = static_cast< unsigned long >(val2);
12279 {
12280 PyThreadState* __tstate = wxPyBeginAllowThreads();
12281 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12282 wxPyEndAllowThreads(__tstate);
12283 if (PyErr_Occurred()) SWIG_fail;
12284 }
12285 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12286 return resultobj;
12287 fail:
12288 return NULL;
12289 }
12290
12291
12292 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12293 PyObject *resultobj = 0;
12294 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12295 byte arg2 ;
12296 byte arg3 ;
12297 byte arg4 ;
12298 unsigned long result;
12299 void *argp1 = 0 ;
12300 int res1 = 0 ;
12301 unsigned char val2 ;
12302 int ecode2 = 0 ;
12303 unsigned char val3 ;
12304 int ecode3 = 0 ;
12305 unsigned char val4 ;
12306 int ecode4 = 0 ;
12307 PyObject * obj0 = 0 ;
12308 PyObject * obj1 = 0 ;
12309 PyObject * obj2 = 0 ;
12310 PyObject * obj3 = 0 ;
12311 char * kwnames[] = {
12312 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12313 };
12314
12315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12317 if (!SWIG_IsOK(res1)) {
12318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12319 }
12320 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12321 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12322 if (!SWIG_IsOK(ecode2)) {
12323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12324 }
12325 arg2 = static_cast< byte >(val2);
12326 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12327 if (!SWIG_IsOK(ecode3)) {
12328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12329 }
12330 arg3 = static_cast< byte >(val3);
12331 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12332 if (!SWIG_IsOK(ecode4)) {
12333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12334 }
12335 arg4 = static_cast< byte >(val4);
12336 {
12337 PyThreadState* __tstate = wxPyBeginAllowThreads();
12338 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12350 PyObject *resultobj = 0;
12351 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12352 wxColour *arg2 = 0 ;
12353 unsigned long result;
12354 void *argp1 = 0 ;
12355 int res1 = 0 ;
12356 wxColour temp2 ;
12357 PyObject * obj0 = 0 ;
12358 PyObject * obj1 = 0 ;
12359 char * kwnames[] = {
12360 (char *) "self",(char *) "colour", NULL
12361 };
12362
12363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12365 if (!SWIG_IsOK(res1)) {
12366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12367 }
12368 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12369 {
12370 arg2 = &temp2;
12371 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12372 }
12373 {
12374 PyThreadState* __tstate = wxPyBeginAllowThreads();
12375 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12376 wxPyEndAllowThreads(__tstate);
12377 if (PyErr_Occurred()) SWIG_fail;
12378 }
12379 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12380 return resultobj;
12381 fail:
12382 return NULL;
12383 }
12384
12385
12386 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12387 PyObject *obj;
12388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12389 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12390 return SWIG_Py_Void();
12391 }
12392
12393 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12394 return SWIG_Python_InitShadowInstance(args);
12395 }
12396
12397 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12398 PyObject *resultobj = 0;
12399 byte arg1 = (byte) 0 ;
12400 byte arg2 = (byte) 0 ;
12401 byte arg3 = (byte) 0 ;
12402 wxImage_RGBValue *result = 0 ;
12403 unsigned char val1 ;
12404 int ecode1 = 0 ;
12405 unsigned char val2 ;
12406 int ecode2 = 0 ;
12407 unsigned char val3 ;
12408 int ecode3 = 0 ;
12409 PyObject * obj0 = 0 ;
12410 PyObject * obj1 = 0 ;
12411 PyObject * obj2 = 0 ;
12412 char * kwnames[] = {
12413 (char *) "r",(char *) "g",(char *) "b", NULL
12414 };
12415
12416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12417 if (obj0) {
12418 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12419 if (!SWIG_IsOK(ecode1)) {
12420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12421 }
12422 arg1 = static_cast< byte >(val1);
12423 }
12424 if (obj1) {
12425 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12426 if (!SWIG_IsOK(ecode2)) {
12427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12428 }
12429 arg2 = static_cast< byte >(val2);
12430 }
12431 if (obj2) {
12432 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12433 if (!SWIG_IsOK(ecode3)) {
12434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12435 }
12436 arg3 = static_cast< byte >(val3);
12437 }
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12445 return resultobj;
12446 fail:
12447 return NULL;
12448 }
12449
12450
12451 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12452 PyObject *resultobj = 0;
12453 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12454 byte arg2 ;
12455 void *argp1 = 0 ;
12456 int res1 = 0 ;
12457 unsigned char val2 ;
12458 int ecode2 = 0 ;
12459 PyObject *swig_obj[2] ;
12460
12461 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12463 if (!SWIG_IsOK(res1)) {
12464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12465 }
12466 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12467 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12468 if (!SWIG_IsOK(ecode2)) {
12469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12470 }
12471 arg2 = static_cast< byte >(val2);
12472 if (arg1) (arg1)->red = arg2;
12473
12474 resultobj = SWIG_Py_Void();
12475 return resultobj;
12476 fail:
12477 return NULL;
12478 }
12479
12480
12481 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12482 PyObject *resultobj = 0;
12483 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12484 byte result;
12485 void *argp1 = 0 ;
12486 int res1 = 0 ;
12487 PyObject *swig_obj[1] ;
12488
12489 if (!args) SWIG_fail;
12490 swig_obj[0] = args;
12491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12492 if (!SWIG_IsOK(res1)) {
12493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12494 }
12495 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12496 result = (byte) ((arg1)->red);
12497 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12498 return resultobj;
12499 fail:
12500 return NULL;
12501 }
12502
12503
12504 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12505 PyObject *resultobj = 0;
12506 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12507 byte arg2 ;
12508 void *argp1 = 0 ;
12509 int res1 = 0 ;
12510 unsigned char val2 ;
12511 int ecode2 = 0 ;
12512 PyObject *swig_obj[2] ;
12513
12514 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12516 if (!SWIG_IsOK(res1)) {
12517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12518 }
12519 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12520 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12521 if (!SWIG_IsOK(ecode2)) {
12522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12523 }
12524 arg2 = static_cast< byte >(val2);
12525 if (arg1) (arg1)->green = arg2;
12526
12527 resultobj = SWIG_Py_Void();
12528 return resultobj;
12529 fail:
12530 return NULL;
12531 }
12532
12533
12534 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12535 PyObject *resultobj = 0;
12536 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12537 byte result;
12538 void *argp1 = 0 ;
12539 int res1 = 0 ;
12540 PyObject *swig_obj[1] ;
12541
12542 if (!args) SWIG_fail;
12543 swig_obj[0] = args;
12544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12545 if (!SWIG_IsOK(res1)) {
12546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12547 }
12548 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12549 result = (byte) ((arg1)->green);
12550 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12551 return resultobj;
12552 fail:
12553 return NULL;
12554 }
12555
12556
12557 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12558 PyObject *resultobj = 0;
12559 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12560 byte arg2 ;
12561 void *argp1 = 0 ;
12562 int res1 = 0 ;
12563 unsigned char val2 ;
12564 int ecode2 = 0 ;
12565 PyObject *swig_obj[2] ;
12566
12567 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12569 if (!SWIG_IsOK(res1)) {
12570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12571 }
12572 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12573 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12574 if (!SWIG_IsOK(ecode2)) {
12575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12576 }
12577 arg2 = static_cast< byte >(val2);
12578 if (arg1) (arg1)->blue = arg2;
12579
12580 resultobj = SWIG_Py_Void();
12581 return resultobj;
12582 fail:
12583 return NULL;
12584 }
12585
12586
12587 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12588 PyObject *resultobj = 0;
12589 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12590 byte result;
12591 void *argp1 = 0 ;
12592 int res1 = 0 ;
12593 PyObject *swig_obj[1] ;
12594
12595 if (!args) SWIG_fail;
12596 swig_obj[0] = args;
12597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12598 if (!SWIG_IsOK(res1)) {
12599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12600 }
12601 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12602 result = (byte) ((arg1)->blue);
12603 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12611 PyObject *obj;
12612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12613 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12614 return SWIG_Py_Void();
12615 }
12616
12617 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12618 return SWIG_Python_InitShadowInstance(args);
12619 }
12620
12621 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12622 PyObject *resultobj = 0;
12623 double arg1 = (double) 0.0 ;
12624 double arg2 = (double) 0.0 ;
12625 double arg3 = (double) 0.0 ;
12626 wxImage_HSVValue *result = 0 ;
12627 double val1 ;
12628 int ecode1 = 0 ;
12629 double val2 ;
12630 int ecode2 = 0 ;
12631 double val3 ;
12632 int ecode3 = 0 ;
12633 PyObject * obj0 = 0 ;
12634 PyObject * obj1 = 0 ;
12635 PyObject * obj2 = 0 ;
12636 char * kwnames[] = {
12637 (char *) "h",(char *) "s",(char *) "v", NULL
12638 };
12639
12640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12641 if (obj0) {
12642 ecode1 = SWIG_AsVal_double(obj0, &val1);
12643 if (!SWIG_IsOK(ecode1)) {
12644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12645 }
12646 arg1 = static_cast< double >(val1);
12647 }
12648 if (obj1) {
12649 ecode2 = SWIG_AsVal_double(obj1, &val2);
12650 if (!SWIG_IsOK(ecode2)) {
12651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12652 }
12653 arg2 = static_cast< double >(val2);
12654 }
12655 if (obj2) {
12656 ecode3 = SWIG_AsVal_double(obj2, &val3);
12657 if (!SWIG_IsOK(ecode3)) {
12658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12659 }
12660 arg3 = static_cast< double >(val3);
12661 }
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12665 wxPyEndAllowThreads(__tstate);
12666 if (PyErr_Occurred()) SWIG_fail;
12667 }
12668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12669 return resultobj;
12670 fail:
12671 return NULL;
12672 }
12673
12674
12675 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12676 PyObject *resultobj = 0;
12677 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12678 double arg2 ;
12679 void *argp1 = 0 ;
12680 int res1 = 0 ;
12681 double val2 ;
12682 int ecode2 = 0 ;
12683 PyObject *swig_obj[2] ;
12684
12685 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12687 if (!SWIG_IsOK(res1)) {
12688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12689 }
12690 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12691 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12692 if (!SWIG_IsOK(ecode2)) {
12693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12694 }
12695 arg2 = static_cast< double >(val2);
12696 if (arg1) (arg1)->hue = arg2;
12697
12698 resultobj = SWIG_Py_Void();
12699 return resultobj;
12700 fail:
12701 return NULL;
12702 }
12703
12704
12705 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12706 PyObject *resultobj = 0;
12707 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12708 double result;
12709 void *argp1 = 0 ;
12710 int res1 = 0 ;
12711 PyObject *swig_obj[1] ;
12712
12713 if (!args) SWIG_fail;
12714 swig_obj[0] = args;
12715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12716 if (!SWIG_IsOK(res1)) {
12717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12718 }
12719 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12720 result = (double) ((arg1)->hue);
12721 resultobj = SWIG_From_double(static_cast< double >(result));
12722 return resultobj;
12723 fail:
12724 return NULL;
12725 }
12726
12727
12728 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12729 PyObject *resultobj = 0;
12730 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12731 double arg2 ;
12732 void *argp1 = 0 ;
12733 int res1 = 0 ;
12734 double val2 ;
12735 int ecode2 = 0 ;
12736 PyObject *swig_obj[2] ;
12737
12738 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12740 if (!SWIG_IsOK(res1)) {
12741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12742 }
12743 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12744 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12745 if (!SWIG_IsOK(ecode2)) {
12746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12747 }
12748 arg2 = static_cast< double >(val2);
12749 if (arg1) (arg1)->saturation = arg2;
12750
12751 resultobj = SWIG_Py_Void();
12752 return resultobj;
12753 fail:
12754 return NULL;
12755 }
12756
12757
12758 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12759 PyObject *resultobj = 0;
12760 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12761 double result;
12762 void *argp1 = 0 ;
12763 int res1 = 0 ;
12764 PyObject *swig_obj[1] ;
12765
12766 if (!args) SWIG_fail;
12767 swig_obj[0] = args;
12768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12769 if (!SWIG_IsOK(res1)) {
12770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12771 }
12772 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12773 result = (double) ((arg1)->saturation);
12774 resultobj = SWIG_From_double(static_cast< double >(result));
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12782 PyObject *resultobj = 0;
12783 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12784 double arg2 ;
12785 void *argp1 = 0 ;
12786 int res1 = 0 ;
12787 double val2 ;
12788 int ecode2 = 0 ;
12789 PyObject *swig_obj[2] ;
12790
12791 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12793 if (!SWIG_IsOK(res1)) {
12794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12795 }
12796 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12797 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12798 if (!SWIG_IsOK(ecode2)) {
12799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12800 }
12801 arg2 = static_cast< double >(val2);
12802 if (arg1) (arg1)->value = arg2;
12803
12804 resultobj = SWIG_Py_Void();
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12812 PyObject *resultobj = 0;
12813 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12814 double result;
12815 void *argp1 = 0 ;
12816 int res1 = 0 ;
12817 PyObject *swig_obj[1] ;
12818
12819 if (!args) SWIG_fail;
12820 swig_obj[0] = args;
12821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12822 if (!SWIG_IsOK(res1)) {
12823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12824 }
12825 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12826 result = (double) ((arg1)->value);
12827 resultobj = SWIG_From_double(static_cast< double >(result));
12828 return resultobj;
12829 fail:
12830 return NULL;
12831 }
12832
12833
12834 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12835 PyObject *obj;
12836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12837 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12838 return SWIG_Py_Void();
12839 }
12840
12841 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12842 return SWIG_Python_InitShadowInstance(args);
12843 }
12844
12845 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12846 PyObject *resultobj = 0;
12847 wxString *arg1 = 0 ;
12848 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12849 int arg3 = (int) -1 ;
12850 wxImage *result = 0 ;
12851 bool temp1 = false ;
12852 long val2 ;
12853 int ecode2 = 0 ;
12854 int val3 ;
12855 int ecode3 = 0 ;
12856 PyObject * obj0 = 0 ;
12857 PyObject * obj1 = 0 ;
12858 PyObject * obj2 = 0 ;
12859 char * kwnames[] = {
12860 (char *) "name",(char *) "type",(char *) "index", NULL
12861 };
12862
12863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12864 {
12865 arg1 = wxString_in_helper(obj0);
12866 if (arg1 == NULL) SWIG_fail;
12867 temp1 = true;
12868 }
12869 if (obj1) {
12870 ecode2 = SWIG_AsVal_long(obj1, &val2);
12871 if (!SWIG_IsOK(ecode2)) {
12872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12873 }
12874 arg2 = static_cast< long >(val2);
12875 }
12876 if (obj2) {
12877 ecode3 = SWIG_AsVal_int(obj2, &val3);
12878 if (!SWIG_IsOK(ecode3)) {
12879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12880 }
12881 arg3 = static_cast< int >(val3);
12882 }
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12890 {
12891 if (temp1)
12892 delete arg1;
12893 }
12894 return resultobj;
12895 fail:
12896 {
12897 if (temp1)
12898 delete arg1;
12899 }
12900 return NULL;
12901 }
12902
12903
12904 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12905 PyObject *resultobj = 0;
12906 wxImage *arg1 = (wxImage *) 0 ;
12907 void *argp1 = 0 ;
12908 int res1 = 0 ;
12909 PyObject *swig_obj[1] ;
12910
12911 if (!args) SWIG_fail;
12912 swig_obj[0] = args;
12913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12914 if (!SWIG_IsOK(res1)) {
12915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12916 }
12917 arg1 = reinterpret_cast< wxImage * >(argp1);
12918 {
12919 PyThreadState* __tstate = wxPyBeginAllowThreads();
12920 delete arg1;
12921
12922 wxPyEndAllowThreads(__tstate);
12923 if (PyErr_Occurred()) SWIG_fail;
12924 }
12925 resultobj = SWIG_Py_Void();
12926 return resultobj;
12927 fail:
12928 return NULL;
12929 }
12930
12931
12932 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12933 PyObject *resultobj = 0;
12934 wxString *arg1 = 0 ;
12935 wxString *arg2 = 0 ;
12936 int arg3 = (int) -1 ;
12937 wxImage *result = 0 ;
12938 bool temp1 = false ;
12939 bool temp2 = false ;
12940 int val3 ;
12941 int ecode3 = 0 ;
12942 PyObject * obj0 = 0 ;
12943 PyObject * obj1 = 0 ;
12944 PyObject * obj2 = 0 ;
12945 char * kwnames[] = {
12946 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12947 };
12948
12949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12950 {
12951 arg1 = wxString_in_helper(obj0);
12952 if (arg1 == NULL) SWIG_fail;
12953 temp1 = true;
12954 }
12955 {
12956 arg2 = wxString_in_helper(obj1);
12957 if (arg2 == NULL) SWIG_fail;
12958 temp2 = true;
12959 }
12960 if (obj2) {
12961 ecode3 = SWIG_AsVal_int(obj2, &val3);
12962 if (!SWIG_IsOK(ecode3)) {
12963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12964 }
12965 arg3 = static_cast< int >(val3);
12966 }
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12974 {
12975 if (temp1)
12976 delete arg1;
12977 }
12978 {
12979 if (temp2)
12980 delete arg2;
12981 }
12982 return resultobj;
12983 fail:
12984 {
12985 if (temp1)
12986 delete arg1;
12987 }
12988 {
12989 if (temp2)
12990 delete arg2;
12991 }
12992 return NULL;
12993 }
12994
12995
12996 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12997 PyObject *resultobj = 0;
12998 wxInputStream *arg1 = 0 ;
12999 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13000 int arg3 = (int) -1 ;
13001 wxImage *result = 0 ;
13002 wxPyInputStream *temp1 ;
13003 bool created1 ;
13004 long val2 ;
13005 int ecode2 = 0 ;
13006 int val3 ;
13007 int ecode3 = 0 ;
13008 PyObject * obj0 = 0 ;
13009 PyObject * obj1 = 0 ;
13010 PyObject * obj2 = 0 ;
13011 char * kwnames[] = {
13012 (char *) "stream",(char *) "type",(char *) "index", NULL
13013 };
13014
13015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13016 {
13017 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13018 arg1 = temp1->m_wxis;
13019 created1 = false;
13020 } else {
13021 PyErr_Clear(); // clear the failure of the wxPyConvert above
13022 arg1 = wxPyCBInputStream_create(obj0, false);
13023 if (arg1 == NULL) {
13024 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13025 SWIG_fail;
13026 }
13027 created1 = true;
13028 }
13029 }
13030 if (obj1) {
13031 ecode2 = SWIG_AsVal_long(obj1, &val2);
13032 if (!SWIG_IsOK(ecode2)) {
13033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13034 }
13035 arg2 = static_cast< long >(val2);
13036 }
13037 if (obj2) {
13038 ecode3 = SWIG_AsVal_int(obj2, &val3);
13039 if (!SWIG_IsOK(ecode3)) {
13040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13041 }
13042 arg3 = static_cast< int >(val3);
13043 }
13044 {
13045 PyThreadState* __tstate = wxPyBeginAllowThreads();
13046 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13051 {
13052 if (created1) delete arg1;
13053 }
13054 return resultobj;
13055 fail:
13056 {
13057 if (created1) delete arg1;
13058 }
13059 return NULL;
13060 }
13061
13062
13063 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13064 PyObject *resultobj = 0;
13065 wxInputStream *arg1 = 0 ;
13066 wxString *arg2 = 0 ;
13067 int arg3 = (int) -1 ;
13068 wxImage *result = 0 ;
13069 wxPyInputStream *temp1 ;
13070 bool created1 ;
13071 bool temp2 = false ;
13072 int val3 ;
13073 int ecode3 = 0 ;
13074 PyObject * obj0 = 0 ;
13075 PyObject * obj1 = 0 ;
13076 PyObject * obj2 = 0 ;
13077 char * kwnames[] = {
13078 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13079 };
13080
13081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13082 {
13083 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13084 arg1 = temp1->m_wxis;
13085 created1 = false;
13086 } else {
13087 PyErr_Clear(); // clear the failure of the wxPyConvert above
13088 arg1 = wxPyCBInputStream_create(obj0, false);
13089 if (arg1 == NULL) {
13090 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13091 SWIG_fail;
13092 }
13093 created1 = true;
13094 }
13095 }
13096 {
13097 arg2 = wxString_in_helper(obj1);
13098 if (arg2 == NULL) SWIG_fail;
13099 temp2 = true;
13100 }
13101 if (obj2) {
13102 ecode3 = SWIG_AsVal_int(obj2, &val3);
13103 if (!SWIG_IsOK(ecode3)) {
13104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13105 }
13106 arg3 = static_cast< int >(val3);
13107 }
13108 {
13109 PyThreadState* __tstate = wxPyBeginAllowThreads();
13110 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13111 wxPyEndAllowThreads(__tstate);
13112 if (PyErr_Occurred()) SWIG_fail;
13113 }
13114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13115 {
13116 if (created1) delete arg1;
13117 }
13118 {
13119 if (temp2)
13120 delete arg2;
13121 }
13122 return resultobj;
13123 fail:
13124 {
13125 if (created1) delete arg1;
13126 }
13127 {
13128 if (temp2)
13129 delete arg2;
13130 }
13131 return NULL;
13132 }
13133
13134
13135 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13136 PyObject *resultobj = 0;
13137 int arg1 = (int) 0 ;
13138 int arg2 = (int) 0 ;
13139 bool arg3 = (bool) true ;
13140 wxImage *result = 0 ;
13141 int val1 ;
13142 int ecode1 = 0 ;
13143 int val2 ;
13144 int ecode2 = 0 ;
13145 bool val3 ;
13146 int ecode3 = 0 ;
13147 PyObject * obj0 = 0 ;
13148 PyObject * obj1 = 0 ;
13149 PyObject * obj2 = 0 ;
13150 char * kwnames[] = {
13151 (char *) "width",(char *) "height",(char *) "clear", NULL
13152 };
13153
13154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13155 if (obj0) {
13156 ecode1 = SWIG_AsVal_int(obj0, &val1);
13157 if (!SWIG_IsOK(ecode1)) {
13158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13159 }
13160 arg1 = static_cast< int >(val1);
13161 }
13162 if (obj1) {
13163 ecode2 = SWIG_AsVal_int(obj1, &val2);
13164 if (!SWIG_IsOK(ecode2)) {
13165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13166 }
13167 arg2 = static_cast< int >(val2);
13168 }
13169 if (obj2) {
13170 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13171 if (!SWIG_IsOK(ecode3)) {
13172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13173 }
13174 arg3 = static_cast< bool >(val3);
13175 }
13176 {
13177 PyThreadState* __tstate = wxPyBeginAllowThreads();
13178 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13179 wxPyEndAllowThreads(__tstate);
13180 if (PyErr_Occurred()) SWIG_fail;
13181 }
13182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13183 return resultobj;
13184 fail:
13185 return NULL;
13186 }
13187
13188
13189 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13190 PyObject *resultobj = 0;
13191 wxBitmap *arg1 = 0 ;
13192 wxImage *result = 0 ;
13193 void *argp1 = 0 ;
13194 int res1 = 0 ;
13195 PyObject * obj0 = 0 ;
13196 char * kwnames[] = {
13197 (char *) "bitmap", NULL
13198 };
13199
13200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13201 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13202 if (!SWIG_IsOK(res1)) {
13203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13204 }
13205 if (!argp1) {
13206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13207 }
13208 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13209 {
13210 if (!wxPyCheckForApp()) SWIG_fail;
13211 PyThreadState* __tstate = wxPyBeginAllowThreads();
13212 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13213 wxPyEndAllowThreads(__tstate);
13214 if (PyErr_Occurred()) SWIG_fail;
13215 }
13216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13217 return resultobj;
13218 fail:
13219 return NULL;
13220 }
13221
13222
13223 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13224 PyObject *resultobj = 0;
13225 int arg1 ;
13226 int arg2 ;
13227 buffer arg3 ;
13228 int arg4 ;
13229 wxImage *result = 0 ;
13230 int val1 ;
13231 int ecode1 = 0 ;
13232 int val2 ;
13233 int ecode2 = 0 ;
13234 PyObject * obj0 = 0 ;
13235 PyObject * obj1 = 0 ;
13236 PyObject * obj2 = 0 ;
13237 char * kwnames[] = {
13238 (char *) "width",(char *) "height",(char *) "data", NULL
13239 };
13240
13241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13242 ecode1 = SWIG_AsVal_int(obj0, &val1);
13243 if (!SWIG_IsOK(ecode1)) {
13244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13245 }
13246 arg1 = static_cast< int >(val1);
13247 ecode2 = SWIG_AsVal_int(obj1, &val2);
13248 if (!SWIG_IsOK(ecode2)) {
13249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13250 }
13251 arg2 = static_cast< int >(val2);
13252 {
13253 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13254 }
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13258 wxPyEndAllowThreads(__tstate);
13259 if (PyErr_Occurred()) SWIG_fail;
13260 }
13261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13262 return resultobj;
13263 fail:
13264 return NULL;
13265 }
13266
13267
13268 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13269 PyObject *resultobj = 0;
13270 int arg1 ;
13271 int arg2 ;
13272 buffer arg3 ;
13273 int arg4 ;
13274 buffer arg5 ;
13275 int arg6 ;
13276 wxImage *result = 0 ;
13277 int val1 ;
13278 int ecode1 = 0 ;
13279 int val2 ;
13280 int ecode2 = 0 ;
13281 PyObject * obj0 = 0 ;
13282 PyObject * obj1 = 0 ;
13283 PyObject * obj2 = 0 ;
13284 PyObject * obj3 = 0 ;
13285 char * kwnames[] = {
13286 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13287 };
13288
13289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13290 ecode1 = SWIG_AsVal_int(obj0, &val1);
13291 if (!SWIG_IsOK(ecode1)) {
13292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13293 }
13294 arg1 = static_cast< int >(val1);
13295 ecode2 = SWIG_AsVal_int(obj1, &val2);
13296 if (!SWIG_IsOK(ecode2)) {
13297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13298 }
13299 arg2 = static_cast< int >(val2);
13300 {
13301 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13302 }
13303 {
13304 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13309 wxPyEndAllowThreads(__tstate);
13310 if (PyErr_Occurred()) SWIG_fail;
13311 }
13312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13313 return resultobj;
13314 fail:
13315 return NULL;
13316 }
13317
13318
13319 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj = 0;
13321 wxImage *arg1 = (wxImage *) 0 ;
13322 int arg2 ;
13323 int arg3 ;
13324 bool arg4 = (bool) true ;
13325 void *argp1 = 0 ;
13326 int res1 = 0 ;
13327 int val2 ;
13328 int ecode2 = 0 ;
13329 int val3 ;
13330 int ecode3 = 0 ;
13331 bool val4 ;
13332 int ecode4 = 0 ;
13333 PyObject * obj0 = 0 ;
13334 PyObject * obj1 = 0 ;
13335 PyObject * obj2 = 0 ;
13336 PyObject * obj3 = 0 ;
13337 char * kwnames[] = {
13338 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13339 };
13340
13341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13343 if (!SWIG_IsOK(res1)) {
13344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13345 }
13346 arg1 = reinterpret_cast< wxImage * >(argp1);
13347 ecode2 = SWIG_AsVal_int(obj1, &val2);
13348 if (!SWIG_IsOK(ecode2)) {
13349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13350 }
13351 arg2 = static_cast< int >(val2);
13352 ecode3 = SWIG_AsVal_int(obj2, &val3);
13353 if (!SWIG_IsOK(ecode3)) {
13354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13355 }
13356 arg3 = static_cast< int >(val3);
13357 if (obj3) {
13358 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13359 if (!SWIG_IsOK(ecode4)) {
13360 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13361 }
13362 arg4 = static_cast< bool >(val4);
13363 }
13364 {
13365 PyThreadState* __tstate = wxPyBeginAllowThreads();
13366 (arg1)->Create(arg2,arg3,arg4);
13367 wxPyEndAllowThreads(__tstate);
13368 if (PyErr_Occurred()) SWIG_fail;
13369 }
13370 resultobj = SWIG_Py_Void();
13371 return resultobj;
13372 fail:
13373 return NULL;
13374 }
13375
13376
13377 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13378 PyObject *resultobj = 0;
13379 wxImage *arg1 = (wxImage *) 0 ;
13380 void *argp1 = 0 ;
13381 int res1 = 0 ;
13382 PyObject *swig_obj[1] ;
13383
13384 if (!args) SWIG_fail;
13385 swig_obj[0] = args;
13386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13387 if (!SWIG_IsOK(res1)) {
13388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13389 }
13390 arg1 = reinterpret_cast< wxImage * >(argp1);
13391 {
13392 PyThreadState* __tstate = wxPyBeginAllowThreads();
13393 (arg1)->Destroy();
13394 wxPyEndAllowThreads(__tstate);
13395 if (PyErr_Occurred()) SWIG_fail;
13396 }
13397 resultobj = SWIG_Py_Void();
13398 return resultobj;
13399 fail:
13400 return NULL;
13401 }
13402
13403
13404 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13405 PyObject *resultobj = 0;
13406 wxImage *arg1 = (wxImage *) 0 ;
13407 int arg2 ;
13408 int arg3 ;
13409 SwigValueWrapper<wxImage > result;
13410 void *argp1 = 0 ;
13411 int res1 = 0 ;
13412 int val2 ;
13413 int ecode2 = 0 ;
13414 int val3 ;
13415 int ecode3 = 0 ;
13416 PyObject * obj0 = 0 ;
13417 PyObject * obj1 = 0 ;
13418 PyObject * obj2 = 0 ;
13419 char * kwnames[] = {
13420 (char *) "self",(char *) "width",(char *) "height", NULL
13421 };
13422
13423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13425 if (!SWIG_IsOK(res1)) {
13426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13427 }
13428 arg1 = reinterpret_cast< wxImage * >(argp1);
13429 ecode2 = SWIG_AsVal_int(obj1, &val2);
13430 if (!SWIG_IsOK(ecode2)) {
13431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13432 }
13433 arg2 = static_cast< int >(val2);
13434 ecode3 = SWIG_AsVal_int(obj2, &val3);
13435 if (!SWIG_IsOK(ecode3)) {
13436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13437 }
13438 arg3 = static_cast< int >(val3);
13439 {
13440 PyThreadState* __tstate = wxPyBeginAllowThreads();
13441 result = (arg1)->Scale(arg2,arg3);
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13446 return resultobj;
13447 fail:
13448 return NULL;
13449 }
13450
13451
13452 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj = 0;
13454 wxImage *arg1 = (wxImage *) 0 ;
13455 int arg2 ;
13456 int arg3 ;
13457 SwigValueWrapper<wxImage > result;
13458 void *argp1 = 0 ;
13459 int res1 = 0 ;
13460 int val2 ;
13461 int ecode2 = 0 ;
13462 int val3 ;
13463 int ecode3 = 0 ;
13464 PyObject * obj0 = 0 ;
13465 PyObject * obj1 = 0 ;
13466 PyObject * obj2 = 0 ;
13467 char * kwnames[] = {
13468 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13469 };
13470
13471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13473 if (!SWIG_IsOK(res1)) {
13474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13475 }
13476 arg1 = reinterpret_cast< wxImage * >(argp1);
13477 ecode2 = SWIG_AsVal_int(obj1, &val2);
13478 if (!SWIG_IsOK(ecode2)) {
13479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13480 }
13481 arg2 = static_cast< int >(val2);
13482 ecode3 = SWIG_AsVal_int(obj2, &val3);
13483 if (!SWIG_IsOK(ecode3)) {
13484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13485 }
13486 arg3 = static_cast< int >(val3);
13487 {
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13494 return resultobj;
13495 fail:
13496 return NULL;
13497 }
13498
13499
13500 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13501 PyObject *resultobj = 0;
13502 wxImage *arg1 = (wxImage *) 0 ;
13503 int arg2 ;
13504 int arg3 ;
13505 wxImage *result = 0 ;
13506 void *argp1 = 0 ;
13507 int res1 = 0 ;
13508 int val2 ;
13509 int ecode2 = 0 ;
13510 int val3 ;
13511 int ecode3 = 0 ;
13512 PyObject * obj0 = 0 ;
13513 PyObject * obj1 = 0 ;
13514 PyObject * obj2 = 0 ;
13515 char * kwnames[] = {
13516 (char *) "self",(char *) "width",(char *) "height", NULL
13517 };
13518
13519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13521 if (!SWIG_IsOK(res1)) {
13522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13523 }
13524 arg1 = reinterpret_cast< wxImage * >(argp1);
13525 ecode2 = SWIG_AsVal_int(obj1, &val2);
13526 if (!SWIG_IsOK(ecode2)) {
13527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13528 }
13529 arg2 = static_cast< int >(val2);
13530 ecode3 = SWIG_AsVal_int(obj2, &val3);
13531 if (!SWIG_IsOK(ecode3)) {
13532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13533 }
13534 arg3 = static_cast< int >(val3);
13535 {
13536 PyThreadState* __tstate = wxPyBeginAllowThreads();
13537 {
13538 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13539 result = (wxImage *) &_result_ref;
13540 }
13541 wxPyEndAllowThreads(__tstate);
13542 if (PyErr_Occurred()) SWIG_fail;
13543 }
13544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13545 return resultobj;
13546 fail:
13547 return NULL;
13548 }
13549
13550
13551 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13552 PyObject *resultobj = 0;
13553 wxImage *arg1 = (wxImage *) 0 ;
13554 wxSize *arg2 = 0 ;
13555 wxPoint *arg3 = 0 ;
13556 int arg4 = (int) -1 ;
13557 int arg5 = (int) -1 ;
13558 int arg6 = (int) -1 ;
13559 wxImage *result = 0 ;
13560 void *argp1 = 0 ;
13561 int res1 = 0 ;
13562 wxSize temp2 ;
13563 wxPoint temp3 ;
13564 int val4 ;
13565 int ecode4 = 0 ;
13566 int val5 ;
13567 int ecode5 = 0 ;
13568 int val6 ;
13569 int ecode6 = 0 ;
13570 PyObject * obj0 = 0 ;
13571 PyObject * obj1 = 0 ;
13572 PyObject * obj2 = 0 ;
13573 PyObject * obj3 = 0 ;
13574 PyObject * obj4 = 0 ;
13575 PyObject * obj5 = 0 ;
13576 char * kwnames[] = {
13577 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13578 };
13579
13580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13582 if (!SWIG_IsOK(res1)) {
13583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13584 }
13585 arg1 = reinterpret_cast< wxImage * >(argp1);
13586 {
13587 arg2 = &temp2;
13588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13589 }
13590 {
13591 arg3 = &temp3;
13592 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13593 }
13594 if (obj3) {
13595 ecode4 = SWIG_AsVal_int(obj3, &val4);
13596 if (!SWIG_IsOK(ecode4)) {
13597 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13598 }
13599 arg4 = static_cast< int >(val4);
13600 }
13601 if (obj4) {
13602 ecode5 = SWIG_AsVal_int(obj4, &val5);
13603 if (!SWIG_IsOK(ecode5)) {
13604 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13605 }
13606 arg5 = static_cast< int >(val5);
13607 }
13608 if (obj5) {
13609 ecode6 = SWIG_AsVal_int(obj5, &val6);
13610 if (!SWIG_IsOK(ecode6)) {
13611 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13612 }
13613 arg6 = static_cast< int >(val6);
13614 }
13615 {
13616 PyThreadState* __tstate = wxPyBeginAllowThreads();
13617 {
13618 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13619 result = (wxImage *) &_result_ref;
13620 }
13621 wxPyEndAllowThreads(__tstate);
13622 if (PyErr_Occurred()) SWIG_fail;
13623 }
13624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13625 return resultobj;
13626 fail:
13627 return NULL;
13628 }
13629
13630
13631 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13632 PyObject *resultobj = 0;
13633 wxImage *arg1 = (wxImage *) 0 ;
13634 int arg2 ;
13635 int arg3 ;
13636 byte arg4 ;
13637 byte arg5 ;
13638 byte arg6 ;
13639 void *argp1 = 0 ;
13640 int res1 = 0 ;
13641 int val2 ;
13642 int ecode2 = 0 ;
13643 int val3 ;
13644 int ecode3 = 0 ;
13645 unsigned char val4 ;
13646 int ecode4 = 0 ;
13647 unsigned char val5 ;
13648 int ecode5 = 0 ;
13649 unsigned char val6 ;
13650 int ecode6 = 0 ;
13651 PyObject * obj0 = 0 ;
13652 PyObject * obj1 = 0 ;
13653 PyObject * obj2 = 0 ;
13654 PyObject * obj3 = 0 ;
13655 PyObject * obj4 = 0 ;
13656 PyObject * obj5 = 0 ;
13657 char * kwnames[] = {
13658 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13659 };
13660
13661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13663 if (!SWIG_IsOK(res1)) {
13664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13665 }
13666 arg1 = reinterpret_cast< wxImage * >(argp1);
13667 ecode2 = SWIG_AsVal_int(obj1, &val2);
13668 if (!SWIG_IsOK(ecode2)) {
13669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13670 }
13671 arg2 = static_cast< int >(val2);
13672 ecode3 = SWIG_AsVal_int(obj2, &val3);
13673 if (!SWIG_IsOK(ecode3)) {
13674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13675 }
13676 arg3 = static_cast< int >(val3);
13677 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13678 if (!SWIG_IsOK(ecode4)) {
13679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13680 }
13681 arg4 = static_cast< byte >(val4);
13682 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13683 if (!SWIG_IsOK(ecode5)) {
13684 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13685 }
13686 arg5 = static_cast< byte >(val5);
13687 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13688 if (!SWIG_IsOK(ecode6)) {
13689 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13690 }
13691 arg6 = static_cast< byte >(val6);
13692 {
13693 PyThreadState* __tstate = wxPyBeginAllowThreads();
13694 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13695 wxPyEndAllowThreads(__tstate);
13696 if (PyErr_Occurred()) SWIG_fail;
13697 }
13698 resultobj = SWIG_Py_Void();
13699 return resultobj;
13700 fail:
13701 return NULL;
13702 }
13703
13704
13705 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13706 PyObject *resultobj = 0;
13707 wxImage *arg1 = (wxImage *) 0 ;
13708 wxRect *arg2 = 0 ;
13709 byte arg3 ;
13710 byte arg4 ;
13711 byte arg5 ;
13712 void *argp1 = 0 ;
13713 int res1 = 0 ;
13714 wxRect temp2 ;
13715 unsigned char val3 ;
13716 int ecode3 = 0 ;
13717 unsigned char val4 ;
13718 int ecode4 = 0 ;
13719 unsigned char val5 ;
13720 int ecode5 = 0 ;
13721 PyObject * obj0 = 0 ;
13722 PyObject * obj1 = 0 ;
13723 PyObject * obj2 = 0 ;
13724 PyObject * obj3 = 0 ;
13725 PyObject * obj4 = 0 ;
13726 char * kwnames[] = {
13727 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13728 };
13729
13730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13732 if (!SWIG_IsOK(res1)) {
13733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13734 }
13735 arg1 = reinterpret_cast< wxImage * >(argp1);
13736 {
13737 arg2 = &temp2;
13738 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13739 }
13740 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13741 if (!SWIG_IsOK(ecode3)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13743 }
13744 arg3 = static_cast< byte >(val3);
13745 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13746 if (!SWIG_IsOK(ecode4)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13748 }
13749 arg4 = static_cast< byte >(val4);
13750 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13751 if (!SWIG_IsOK(ecode5)) {
13752 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13753 }
13754 arg5 = static_cast< byte >(val5);
13755 {
13756 PyThreadState* __tstate = wxPyBeginAllowThreads();
13757 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13758 wxPyEndAllowThreads(__tstate);
13759 if (PyErr_Occurred()) SWIG_fail;
13760 }
13761 resultobj = SWIG_Py_Void();
13762 return resultobj;
13763 fail:
13764 return NULL;
13765 }
13766
13767
13768 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13769 PyObject *resultobj = 0;
13770 wxImage *arg1 = (wxImage *) 0 ;
13771 int arg2 ;
13772 int arg3 ;
13773 byte result;
13774 void *argp1 = 0 ;
13775 int res1 = 0 ;
13776 int val2 ;
13777 int ecode2 = 0 ;
13778 int val3 ;
13779 int ecode3 = 0 ;
13780 PyObject * obj0 = 0 ;
13781 PyObject * obj1 = 0 ;
13782 PyObject * obj2 = 0 ;
13783 char * kwnames[] = {
13784 (char *) "self",(char *) "x",(char *) "y", NULL
13785 };
13786
13787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13789 if (!SWIG_IsOK(res1)) {
13790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13791 }
13792 arg1 = reinterpret_cast< wxImage * >(argp1);
13793 ecode2 = SWIG_AsVal_int(obj1, &val2);
13794 if (!SWIG_IsOK(ecode2)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13796 }
13797 arg2 = static_cast< int >(val2);
13798 ecode3 = SWIG_AsVal_int(obj2, &val3);
13799 if (!SWIG_IsOK(ecode3)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13801 }
13802 arg3 = static_cast< int >(val3);
13803 {
13804 PyThreadState* __tstate = wxPyBeginAllowThreads();
13805 result = (byte)(arg1)->GetRed(arg2,arg3);
13806 wxPyEndAllowThreads(__tstate);
13807 if (PyErr_Occurred()) SWIG_fail;
13808 }
13809 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13810 return resultobj;
13811 fail:
13812 return NULL;
13813 }
13814
13815
13816 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13817 PyObject *resultobj = 0;
13818 wxImage *arg1 = (wxImage *) 0 ;
13819 int arg2 ;
13820 int arg3 ;
13821 byte result;
13822 void *argp1 = 0 ;
13823 int res1 = 0 ;
13824 int val2 ;
13825 int ecode2 = 0 ;
13826 int val3 ;
13827 int ecode3 = 0 ;
13828 PyObject * obj0 = 0 ;
13829 PyObject * obj1 = 0 ;
13830 PyObject * obj2 = 0 ;
13831 char * kwnames[] = {
13832 (char *) "self",(char *) "x",(char *) "y", NULL
13833 };
13834
13835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13837 if (!SWIG_IsOK(res1)) {
13838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13839 }
13840 arg1 = reinterpret_cast< wxImage * >(argp1);
13841 ecode2 = SWIG_AsVal_int(obj1, &val2);
13842 if (!SWIG_IsOK(ecode2)) {
13843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13844 }
13845 arg2 = static_cast< int >(val2);
13846 ecode3 = SWIG_AsVal_int(obj2, &val3);
13847 if (!SWIG_IsOK(ecode3)) {
13848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13849 }
13850 arg3 = static_cast< int >(val3);
13851 {
13852 PyThreadState* __tstate = wxPyBeginAllowThreads();
13853 result = (byte)(arg1)->GetGreen(arg2,arg3);
13854 wxPyEndAllowThreads(__tstate);
13855 if (PyErr_Occurred()) SWIG_fail;
13856 }
13857 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13858 return resultobj;
13859 fail:
13860 return NULL;
13861 }
13862
13863
13864 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13865 PyObject *resultobj = 0;
13866 wxImage *arg1 = (wxImage *) 0 ;
13867 int arg2 ;
13868 int arg3 ;
13869 byte result;
13870 void *argp1 = 0 ;
13871 int res1 = 0 ;
13872 int val2 ;
13873 int ecode2 = 0 ;
13874 int val3 ;
13875 int ecode3 = 0 ;
13876 PyObject * obj0 = 0 ;
13877 PyObject * obj1 = 0 ;
13878 PyObject * obj2 = 0 ;
13879 char * kwnames[] = {
13880 (char *) "self",(char *) "x",(char *) "y", NULL
13881 };
13882
13883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13885 if (!SWIG_IsOK(res1)) {
13886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13887 }
13888 arg1 = reinterpret_cast< wxImage * >(argp1);
13889 ecode2 = SWIG_AsVal_int(obj1, &val2);
13890 if (!SWIG_IsOK(ecode2)) {
13891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13892 }
13893 arg2 = static_cast< int >(val2);
13894 ecode3 = SWIG_AsVal_int(obj2, &val3);
13895 if (!SWIG_IsOK(ecode3)) {
13896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13897 }
13898 arg3 = static_cast< int >(val3);
13899 {
13900 PyThreadState* __tstate = wxPyBeginAllowThreads();
13901 result = (byte)(arg1)->GetBlue(arg2,arg3);
13902 wxPyEndAllowThreads(__tstate);
13903 if (PyErr_Occurred()) SWIG_fail;
13904 }
13905 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13906 return resultobj;
13907 fail:
13908 return NULL;
13909 }
13910
13911
13912 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13913 PyObject *resultobj = 0;
13914 wxImage *arg1 = (wxImage *) 0 ;
13915 int arg2 ;
13916 int arg3 ;
13917 byte arg4 ;
13918 void *argp1 = 0 ;
13919 int res1 = 0 ;
13920 int val2 ;
13921 int ecode2 = 0 ;
13922 int val3 ;
13923 int ecode3 = 0 ;
13924 unsigned char val4 ;
13925 int ecode4 = 0 ;
13926 PyObject * obj0 = 0 ;
13927 PyObject * obj1 = 0 ;
13928 PyObject * obj2 = 0 ;
13929 PyObject * obj3 = 0 ;
13930 char * kwnames[] = {
13931 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13932 };
13933
13934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13936 if (!SWIG_IsOK(res1)) {
13937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13938 }
13939 arg1 = reinterpret_cast< wxImage * >(argp1);
13940 ecode2 = SWIG_AsVal_int(obj1, &val2);
13941 if (!SWIG_IsOK(ecode2)) {
13942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13943 }
13944 arg2 = static_cast< int >(val2);
13945 ecode3 = SWIG_AsVal_int(obj2, &val3);
13946 if (!SWIG_IsOK(ecode3)) {
13947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13948 }
13949 arg3 = static_cast< int >(val3);
13950 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13951 if (!SWIG_IsOK(ecode4)) {
13952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13953 }
13954 arg4 = static_cast< byte >(val4);
13955 {
13956 PyThreadState* __tstate = wxPyBeginAllowThreads();
13957 (arg1)->SetAlpha(arg2,arg3,arg4);
13958 wxPyEndAllowThreads(__tstate);
13959 if (PyErr_Occurred()) SWIG_fail;
13960 }
13961 resultobj = SWIG_Py_Void();
13962 return resultobj;
13963 fail:
13964 return NULL;
13965 }
13966
13967
13968 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13969 PyObject *resultobj = 0;
13970 wxImage *arg1 = (wxImage *) 0 ;
13971 int arg2 ;
13972 int arg3 ;
13973 byte result;
13974 void *argp1 = 0 ;
13975 int res1 = 0 ;
13976 int val2 ;
13977 int ecode2 = 0 ;
13978 int val3 ;
13979 int ecode3 = 0 ;
13980 PyObject * obj0 = 0 ;
13981 PyObject * obj1 = 0 ;
13982 PyObject * obj2 = 0 ;
13983 char * kwnames[] = {
13984 (char *) "self",(char *) "x",(char *) "y", NULL
13985 };
13986
13987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13989 if (!SWIG_IsOK(res1)) {
13990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13991 }
13992 arg1 = reinterpret_cast< wxImage * >(argp1);
13993 ecode2 = SWIG_AsVal_int(obj1, &val2);
13994 if (!SWIG_IsOK(ecode2)) {
13995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13996 }
13997 arg2 = static_cast< int >(val2);
13998 ecode3 = SWIG_AsVal_int(obj2, &val3);
13999 if (!SWIG_IsOK(ecode3)) {
14000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14001 }
14002 arg3 = static_cast< int >(val3);
14003 {
14004 PyThreadState* __tstate = wxPyBeginAllowThreads();
14005 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14006 wxPyEndAllowThreads(__tstate);
14007 if (PyErr_Occurred()) SWIG_fail;
14008 }
14009 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14010 return resultobj;
14011 fail:
14012 return NULL;
14013 }
14014
14015
14016 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14017 PyObject *resultobj = 0;
14018 wxImage *arg1 = (wxImage *) 0 ;
14019 bool result;
14020 void *argp1 = 0 ;
14021 int res1 = 0 ;
14022 PyObject *swig_obj[1] ;
14023
14024 if (!args) SWIG_fail;
14025 swig_obj[0] = args;
14026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14027 if (!SWIG_IsOK(res1)) {
14028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14029 }
14030 arg1 = reinterpret_cast< wxImage * >(argp1);
14031 {
14032 PyThreadState* __tstate = wxPyBeginAllowThreads();
14033 result = (bool)(arg1)->HasAlpha();
14034 wxPyEndAllowThreads(__tstate);
14035 if (PyErr_Occurred()) SWIG_fail;
14036 }
14037 {
14038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14039 }
14040 return resultobj;
14041 fail:
14042 return NULL;
14043 }
14044
14045
14046 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14047 PyObject *resultobj = 0;
14048 wxImage *arg1 = (wxImage *) 0 ;
14049 void *argp1 = 0 ;
14050 int res1 = 0 ;
14051 PyObject *swig_obj[1] ;
14052
14053 if (!args) SWIG_fail;
14054 swig_obj[0] = args;
14055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14056 if (!SWIG_IsOK(res1)) {
14057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14058 }
14059 arg1 = reinterpret_cast< wxImage * >(argp1);
14060 {
14061 PyThreadState* __tstate = wxPyBeginAllowThreads();
14062 (arg1)->InitAlpha();
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 resultobj = SWIG_Py_Void();
14067 return resultobj;
14068 fail:
14069 return NULL;
14070 }
14071
14072
14073 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14074 PyObject *resultobj = 0;
14075 wxImage *arg1 = (wxImage *) 0 ;
14076 int arg2 ;
14077 int arg3 ;
14078 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14079 bool result;
14080 void *argp1 = 0 ;
14081 int res1 = 0 ;
14082 int val2 ;
14083 int ecode2 = 0 ;
14084 int val3 ;
14085 int ecode3 = 0 ;
14086 unsigned char val4 ;
14087 int ecode4 = 0 ;
14088 PyObject * obj0 = 0 ;
14089 PyObject * obj1 = 0 ;
14090 PyObject * obj2 = 0 ;
14091 PyObject * obj3 = 0 ;
14092 char * kwnames[] = {
14093 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14094 };
14095
14096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14098 if (!SWIG_IsOK(res1)) {
14099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14100 }
14101 arg1 = reinterpret_cast< wxImage * >(argp1);
14102 ecode2 = SWIG_AsVal_int(obj1, &val2);
14103 if (!SWIG_IsOK(ecode2)) {
14104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14105 }
14106 arg2 = static_cast< int >(val2);
14107 ecode3 = SWIG_AsVal_int(obj2, &val3);
14108 if (!SWIG_IsOK(ecode3)) {
14109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14110 }
14111 arg3 = static_cast< int >(val3);
14112 if (obj3) {
14113 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14114 if (!SWIG_IsOK(ecode4)) {
14115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14116 }
14117 arg4 = static_cast< byte >(val4);
14118 }
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 {
14126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14127 }
14128 return resultobj;
14129 fail:
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14135 PyObject *resultobj = 0;
14136 wxImage *arg1 = (wxImage *) 0 ;
14137 byte *arg2 = (byte *) 0 ;
14138 byte *arg3 = (byte *) 0 ;
14139 byte *arg4 = (byte *) 0 ;
14140 byte arg5 = (byte) 0 ;
14141 byte arg6 = (byte) 0 ;
14142 byte arg7 = (byte) 0 ;
14143 bool result;
14144 void *argp1 = 0 ;
14145 int res1 = 0 ;
14146 byte temp2 ;
14147 int res2 = SWIG_TMPOBJ ;
14148 byte temp3 ;
14149 int res3 = SWIG_TMPOBJ ;
14150 byte temp4 ;
14151 int res4 = SWIG_TMPOBJ ;
14152 unsigned char val5 ;
14153 int ecode5 = 0 ;
14154 unsigned char val6 ;
14155 int ecode6 = 0 ;
14156 unsigned char val7 ;
14157 int ecode7 = 0 ;
14158 PyObject * obj0 = 0 ;
14159 PyObject * obj1 = 0 ;
14160 PyObject * obj2 = 0 ;
14161 PyObject * obj3 = 0 ;
14162 char * kwnames[] = {
14163 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14164 };
14165
14166 arg2 = &temp2;
14167 arg3 = &temp3;
14168 arg4 = &temp4;
14169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14171 if (!SWIG_IsOK(res1)) {
14172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14173 }
14174 arg1 = reinterpret_cast< wxImage * >(argp1);
14175 if (obj1) {
14176 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14177 if (!SWIG_IsOK(ecode5)) {
14178 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14179 }
14180 arg5 = static_cast< byte >(val5);
14181 }
14182 if (obj2) {
14183 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14184 if (!SWIG_IsOK(ecode6)) {
14185 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14186 }
14187 arg6 = static_cast< byte >(val6);
14188 }
14189 if (obj3) {
14190 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14191 if (!SWIG_IsOK(ecode7)) {
14192 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14193 }
14194 arg7 = static_cast< byte >(val7);
14195 }
14196 {
14197 PyThreadState* __tstate = wxPyBeginAllowThreads();
14198 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14199 wxPyEndAllowThreads(__tstate);
14200 if (PyErr_Occurred()) SWIG_fail;
14201 }
14202 {
14203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14204 }
14205 if (SWIG_IsTmpObj(res2)) {
14206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14207 } else {
14208 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14210 }
14211 if (SWIG_IsTmpObj(res3)) {
14212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14213 } else {
14214 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14216 }
14217 if (SWIG_IsTmpObj(res4)) {
14218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14219 } else {
14220 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14222 }
14223 return resultobj;
14224 fail:
14225 return NULL;
14226 }
14227
14228
14229 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14230 PyObject *resultobj = 0;
14231 wxImage *arg1 = (wxImage *) 0 ;
14232 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14233 bool result;
14234 void *argp1 = 0 ;
14235 int res1 = 0 ;
14236 unsigned char val2 ;
14237 int ecode2 = 0 ;
14238 PyObject * obj0 = 0 ;
14239 PyObject * obj1 = 0 ;
14240 char * kwnames[] = {
14241 (char *) "self",(char *) "threshold", NULL
14242 };
14243
14244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14246 if (!SWIG_IsOK(res1)) {
14247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14248 }
14249 arg1 = reinterpret_cast< wxImage * >(argp1);
14250 if (obj1) {
14251 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14252 if (!SWIG_IsOK(ecode2)) {
14253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14254 }
14255 arg2 = static_cast< byte >(val2);
14256 }
14257 {
14258 PyThreadState* __tstate = wxPyBeginAllowThreads();
14259 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14260 wxPyEndAllowThreads(__tstate);
14261 if (PyErr_Occurred()) SWIG_fail;
14262 }
14263 {
14264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14265 }
14266 return resultobj;
14267 fail:
14268 return NULL;
14269 }
14270
14271
14272 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14273 PyObject *resultobj = 0;
14274 wxImage *arg1 = (wxImage *) 0 ;
14275 byte arg2 ;
14276 byte arg3 ;
14277 byte arg4 ;
14278 bool result;
14279 void *argp1 = 0 ;
14280 int res1 = 0 ;
14281 unsigned char val2 ;
14282 int ecode2 = 0 ;
14283 unsigned char val3 ;
14284 int ecode3 = 0 ;
14285 unsigned char val4 ;
14286 int ecode4 = 0 ;
14287 PyObject * obj0 = 0 ;
14288 PyObject * obj1 = 0 ;
14289 PyObject * obj2 = 0 ;
14290 PyObject * obj3 = 0 ;
14291 char * kwnames[] = {
14292 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14293 };
14294
14295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14297 if (!SWIG_IsOK(res1)) {
14298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14299 }
14300 arg1 = reinterpret_cast< wxImage * >(argp1);
14301 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14302 if (!SWIG_IsOK(ecode2)) {
14303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14304 }
14305 arg2 = static_cast< byte >(val2);
14306 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14307 if (!SWIG_IsOK(ecode3)) {
14308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14309 }
14310 arg3 = static_cast< byte >(val3);
14311 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14312 if (!SWIG_IsOK(ecode4)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14314 }
14315 arg4 = static_cast< byte >(val4);
14316 {
14317 PyThreadState* __tstate = wxPyBeginAllowThreads();
14318 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14319 wxPyEndAllowThreads(__tstate);
14320 if (PyErr_Occurred()) SWIG_fail;
14321 }
14322 {
14323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14324 }
14325 return resultobj;
14326 fail:
14327 return NULL;
14328 }
14329
14330
14331 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14332 PyObject *resultobj = 0;
14333 wxImage *arg1 = (wxImage *) 0 ;
14334 wxImage *arg2 = 0 ;
14335 byte arg3 ;
14336 byte arg4 ;
14337 byte arg5 ;
14338 bool result;
14339 void *argp1 = 0 ;
14340 int res1 = 0 ;
14341 void *argp2 = 0 ;
14342 int res2 = 0 ;
14343 unsigned char val3 ;
14344 int ecode3 = 0 ;
14345 unsigned char val4 ;
14346 int ecode4 = 0 ;
14347 unsigned char val5 ;
14348 int ecode5 = 0 ;
14349 PyObject * obj0 = 0 ;
14350 PyObject * obj1 = 0 ;
14351 PyObject * obj2 = 0 ;
14352 PyObject * obj3 = 0 ;
14353 PyObject * obj4 = 0 ;
14354 char * kwnames[] = {
14355 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14356 };
14357
14358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14360 if (!SWIG_IsOK(res1)) {
14361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14362 }
14363 arg1 = reinterpret_cast< wxImage * >(argp1);
14364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14365 if (!SWIG_IsOK(res2)) {
14366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14367 }
14368 if (!argp2) {
14369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14370 }
14371 arg2 = reinterpret_cast< wxImage * >(argp2);
14372 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14373 if (!SWIG_IsOK(ecode3)) {
14374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14375 }
14376 arg3 = static_cast< byte >(val3);
14377 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14378 if (!SWIG_IsOK(ecode4)) {
14379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14380 }
14381 arg4 = static_cast< byte >(val4);
14382 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14383 if (!SWIG_IsOK(ecode5)) {
14384 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14385 }
14386 arg5 = static_cast< byte >(val5);
14387 {
14388 PyThreadState* __tstate = wxPyBeginAllowThreads();
14389 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14390 wxPyEndAllowThreads(__tstate);
14391 if (PyErr_Occurred()) SWIG_fail;
14392 }
14393 {
14394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14395 }
14396 return resultobj;
14397 fail:
14398 return NULL;
14399 }
14400
14401
14402 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14403 PyObject *resultobj = 0;
14404 wxString *arg1 = 0 ;
14405 bool result;
14406 bool temp1 = false ;
14407 PyObject * obj0 = 0 ;
14408 char * kwnames[] = {
14409 (char *) "filename", NULL
14410 };
14411
14412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14413 {
14414 arg1 = wxString_in_helper(obj0);
14415 if (arg1 == NULL) SWIG_fail;
14416 temp1 = true;
14417 }
14418 {
14419 PyThreadState* __tstate = wxPyBeginAllowThreads();
14420 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14421 wxPyEndAllowThreads(__tstate);
14422 if (PyErr_Occurred()) SWIG_fail;
14423 }
14424 {
14425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14426 }
14427 {
14428 if (temp1)
14429 delete arg1;
14430 }
14431 return resultobj;
14432 fail:
14433 {
14434 if (temp1)
14435 delete arg1;
14436 }
14437 return NULL;
14438 }
14439
14440
14441 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14442 PyObject *resultobj = 0;
14443 wxString *arg1 = 0 ;
14444 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14445 int result;
14446 bool temp1 = false ;
14447 long val2 ;
14448 int ecode2 = 0 ;
14449 PyObject * obj0 = 0 ;
14450 PyObject * obj1 = 0 ;
14451 char * kwnames[] = {
14452 (char *) "filename",(char *) "type", NULL
14453 };
14454
14455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14456 {
14457 arg1 = wxString_in_helper(obj0);
14458 if (arg1 == NULL) SWIG_fail;
14459 temp1 = true;
14460 }
14461 if (obj1) {
14462 ecode2 = SWIG_AsVal_long(obj1, &val2);
14463 if (!SWIG_IsOK(ecode2)) {
14464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14465 }
14466 arg2 = static_cast< long >(val2);
14467 }
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 resultobj = SWIG_From_int(static_cast< int >(result));
14475 {
14476 if (temp1)
14477 delete arg1;
14478 }
14479 return resultobj;
14480 fail:
14481 {
14482 if (temp1)
14483 delete arg1;
14484 }
14485 return NULL;
14486 }
14487
14488
14489 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14490 PyObject *resultobj = 0;
14491 wxImage *arg1 = (wxImage *) 0 ;
14492 wxString *arg2 = 0 ;
14493 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14494 int arg4 = (int) -1 ;
14495 bool result;
14496 void *argp1 = 0 ;
14497 int res1 = 0 ;
14498 bool temp2 = false ;
14499 long val3 ;
14500 int ecode3 = 0 ;
14501 int val4 ;
14502 int ecode4 = 0 ;
14503 PyObject * obj0 = 0 ;
14504 PyObject * obj1 = 0 ;
14505 PyObject * obj2 = 0 ;
14506 PyObject * obj3 = 0 ;
14507 char * kwnames[] = {
14508 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14509 };
14510
14511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14513 if (!SWIG_IsOK(res1)) {
14514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14515 }
14516 arg1 = reinterpret_cast< wxImage * >(argp1);
14517 {
14518 arg2 = wxString_in_helper(obj1);
14519 if (arg2 == NULL) SWIG_fail;
14520 temp2 = true;
14521 }
14522 if (obj2) {
14523 ecode3 = SWIG_AsVal_long(obj2, &val3);
14524 if (!SWIG_IsOK(ecode3)) {
14525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14526 }
14527 arg3 = static_cast< long >(val3);
14528 }
14529 if (obj3) {
14530 ecode4 = SWIG_AsVal_int(obj3, &val4);
14531 if (!SWIG_IsOK(ecode4)) {
14532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14533 }
14534 arg4 = static_cast< int >(val4);
14535 }
14536 {
14537 PyThreadState* __tstate = wxPyBeginAllowThreads();
14538 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14539 wxPyEndAllowThreads(__tstate);
14540 if (PyErr_Occurred()) SWIG_fail;
14541 }
14542 {
14543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14544 }
14545 {
14546 if (temp2)
14547 delete arg2;
14548 }
14549 return resultobj;
14550 fail:
14551 {
14552 if (temp2)
14553 delete arg2;
14554 }
14555 return NULL;
14556 }
14557
14558
14559 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14560 PyObject *resultobj = 0;
14561 wxImage *arg1 = (wxImage *) 0 ;
14562 wxString *arg2 = 0 ;
14563 wxString *arg3 = 0 ;
14564 int arg4 = (int) -1 ;
14565 bool result;
14566 void *argp1 = 0 ;
14567 int res1 = 0 ;
14568 bool temp2 = false ;
14569 bool temp3 = false ;
14570 int val4 ;
14571 int ecode4 = 0 ;
14572 PyObject * obj0 = 0 ;
14573 PyObject * obj1 = 0 ;
14574 PyObject * obj2 = 0 ;
14575 PyObject * obj3 = 0 ;
14576 char * kwnames[] = {
14577 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14578 };
14579
14580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14582 if (!SWIG_IsOK(res1)) {
14583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14584 }
14585 arg1 = reinterpret_cast< wxImage * >(argp1);
14586 {
14587 arg2 = wxString_in_helper(obj1);
14588 if (arg2 == NULL) SWIG_fail;
14589 temp2 = true;
14590 }
14591 {
14592 arg3 = wxString_in_helper(obj2);
14593 if (arg3 == NULL) SWIG_fail;
14594 temp3 = true;
14595 }
14596 if (obj3) {
14597 ecode4 = SWIG_AsVal_int(obj3, &val4);
14598 if (!SWIG_IsOK(ecode4)) {
14599 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14600 }
14601 arg4 = static_cast< int >(val4);
14602 }
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14606 wxPyEndAllowThreads(__tstate);
14607 if (PyErr_Occurred()) SWIG_fail;
14608 }
14609 {
14610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14611 }
14612 {
14613 if (temp2)
14614 delete arg2;
14615 }
14616 {
14617 if (temp3)
14618 delete arg3;
14619 }
14620 return resultobj;
14621 fail:
14622 {
14623 if (temp2)
14624 delete arg2;
14625 }
14626 {
14627 if (temp3)
14628 delete arg3;
14629 }
14630 return NULL;
14631 }
14632
14633
14634 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14635 PyObject *resultobj = 0;
14636 wxImage *arg1 = (wxImage *) 0 ;
14637 wxString *arg2 = 0 ;
14638 int arg3 ;
14639 bool result;
14640 void *argp1 = 0 ;
14641 int res1 = 0 ;
14642 bool temp2 = false ;
14643 int val3 ;
14644 int ecode3 = 0 ;
14645 PyObject * obj0 = 0 ;
14646 PyObject * obj1 = 0 ;
14647 PyObject * obj2 = 0 ;
14648 char * kwnames[] = {
14649 (char *) "self",(char *) "name",(char *) "type", NULL
14650 };
14651
14652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14654 if (!SWIG_IsOK(res1)) {
14655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14656 }
14657 arg1 = reinterpret_cast< wxImage * >(argp1);
14658 {
14659 arg2 = wxString_in_helper(obj1);
14660 if (arg2 == NULL) SWIG_fail;
14661 temp2 = true;
14662 }
14663 ecode3 = SWIG_AsVal_int(obj2, &val3);
14664 if (!SWIG_IsOK(ecode3)) {
14665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14666 }
14667 arg3 = static_cast< int >(val3);
14668 {
14669 PyThreadState* __tstate = wxPyBeginAllowThreads();
14670 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14671 wxPyEndAllowThreads(__tstate);
14672 if (PyErr_Occurred()) SWIG_fail;
14673 }
14674 {
14675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14676 }
14677 {
14678 if (temp2)
14679 delete arg2;
14680 }
14681 return resultobj;
14682 fail:
14683 {
14684 if (temp2)
14685 delete arg2;
14686 }
14687 return NULL;
14688 }
14689
14690
14691 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj = 0;
14693 wxImage *arg1 = (wxImage *) 0 ;
14694 wxString *arg2 = 0 ;
14695 wxString *arg3 = 0 ;
14696 bool result;
14697 void *argp1 = 0 ;
14698 int res1 = 0 ;
14699 bool temp2 = false ;
14700 bool temp3 = false ;
14701 PyObject * obj0 = 0 ;
14702 PyObject * obj1 = 0 ;
14703 PyObject * obj2 = 0 ;
14704 char * kwnames[] = {
14705 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14706 };
14707
14708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14710 if (!SWIG_IsOK(res1)) {
14711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14712 }
14713 arg1 = reinterpret_cast< wxImage * >(argp1);
14714 {
14715 arg2 = wxString_in_helper(obj1);
14716 if (arg2 == NULL) SWIG_fail;
14717 temp2 = true;
14718 }
14719 {
14720 arg3 = wxString_in_helper(obj2);
14721 if (arg3 == NULL) SWIG_fail;
14722 temp3 = true;
14723 }
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14727 wxPyEndAllowThreads(__tstate);
14728 if (PyErr_Occurred()) SWIG_fail;
14729 }
14730 {
14731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14732 }
14733 {
14734 if (temp2)
14735 delete arg2;
14736 }
14737 {
14738 if (temp3)
14739 delete arg3;
14740 }
14741 return resultobj;
14742 fail:
14743 {
14744 if (temp2)
14745 delete arg2;
14746 }
14747 {
14748 if (temp3)
14749 delete arg3;
14750 }
14751 return NULL;
14752 }
14753
14754
14755 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14756 PyObject *resultobj = 0;
14757 wxInputStream *arg1 = 0 ;
14758 bool result;
14759 wxPyInputStream *temp1 ;
14760 bool created1 ;
14761 PyObject * obj0 = 0 ;
14762 char * kwnames[] = {
14763 (char *) "stream", NULL
14764 };
14765
14766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14767 {
14768 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14769 arg1 = temp1->m_wxis;
14770 created1 = false;
14771 } else {
14772 PyErr_Clear(); // clear the failure of the wxPyConvert above
14773 arg1 = wxPyCBInputStream_create(obj0, false);
14774 if (arg1 == NULL) {
14775 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14776 SWIG_fail;
14777 }
14778 created1 = true;
14779 }
14780 }
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 result = (bool)wxImage::CanRead(*arg1);
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 {
14788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14789 }
14790 {
14791 if (created1) delete arg1;
14792 }
14793 return resultobj;
14794 fail:
14795 {
14796 if (created1) delete arg1;
14797 }
14798 return NULL;
14799 }
14800
14801
14802 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14803 PyObject *resultobj = 0;
14804 wxImage *arg1 = (wxImage *) 0 ;
14805 wxInputStream *arg2 = 0 ;
14806 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14807 int arg4 = (int) -1 ;
14808 bool result;
14809 void *argp1 = 0 ;
14810 int res1 = 0 ;
14811 wxPyInputStream *temp2 ;
14812 bool created2 ;
14813 long val3 ;
14814 int ecode3 = 0 ;
14815 int val4 ;
14816 int ecode4 = 0 ;
14817 PyObject * obj0 = 0 ;
14818 PyObject * obj1 = 0 ;
14819 PyObject * obj2 = 0 ;
14820 PyObject * obj3 = 0 ;
14821 char * kwnames[] = {
14822 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14823 };
14824
14825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14829 }
14830 arg1 = reinterpret_cast< wxImage * >(argp1);
14831 {
14832 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14833 arg2 = temp2->m_wxis;
14834 created2 = false;
14835 } else {
14836 PyErr_Clear(); // clear the failure of the wxPyConvert above
14837 arg2 = wxPyCBInputStream_create(obj1, false);
14838 if (arg2 == NULL) {
14839 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14840 SWIG_fail;
14841 }
14842 created2 = true;
14843 }
14844 }
14845 if (obj2) {
14846 ecode3 = SWIG_AsVal_long(obj2, &val3);
14847 if (!SWIG_IsOK(ecode3)) {
14848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14849 }
14850 arg3 = static_cast< long >(val3);
14851 }
14852 if (obj3) {
14853 ecode4 = SWIG_AsVal_int(obj3, &val4);
14854 if (!SWIG_IsOK(ecode4)) {
14855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14856 }
14857 arg4 = static_cast< int >(val4);
14858 }
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 {
14866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14867 }
14868 {
14869 if (created2) delete arg2;
14870 }
14871 return resultobj;
14872 fail:
14873 {
14874 if (created2) delete arg2;
14875 }
14876 return NULL;
14877 }
14878
14879
14880 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14881 PyObject *resultobj = 0;
14882 wxImage *arg1 = (wxImage *) 0 ;
14883 wxInputStream *arg2 = 0 ;
14884 wxString *arg3 = 0 ;
14885 int arg4 = (int) -1 ;
14886 bool result;
14887 void *argp1 = 0 ;
14888 int res1 = 0 ;
14889 wxPyInputStream *temp2 ;
14890 bool created2 ;
14891 bool temp3 = false ;
14892 int val4 ;
14893 int ecode4 = 0 ;
14894 PyObject * obj0 = 0 ;
14895 PyObject * obj1 = 0 ;
14896 PyObject * obj2 = 0 ;
14897 PyObject * obj3 = 0 ;
14898 char * kwnames[] = {
14899 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14900 };
14901
14902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14904 if (!SWIG_IsOK(res1)) {
14905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14906 }
14907 arg1 = reinterpret_cast< wxImage * >(argp1);
14908 {
14909 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14910 arg2 = temp2->m_wxis;
14911 created2 = false;
14912 } else {
14913 PyErr_Clear(); // clear the failure of the wxPyConvert above
14914 arg2 = wxPyCBInputStream_create(obj1, false);
14915 if (arg2 == NULL) {
14916 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14917 SWIG_fail;
14918 }
14919 created2 = true;
14920 }
14921 }
14922 {
14923 arg3 = wxString_in_helper(obj2);
14924 if (arg3 == NULL) SWIG_fail;
14925 temp3 = true;
14926 }
14927 if (obj3) {
14928 ecode4 = SWIG_AsVal_int(obj3, &val4);
14929 if (!SWIG_IsOK(ecode4)) {
14930 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14931 }
14932 arg4 = static_cast< int >(val4);
14933 }
14934 {
14935 PyThreadState* __tstate = wxPyBeginAllowThreads();
14936 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14937 wxPyEndAllowThreads(__tstate);
14938 if (PyErr_Occurred()) SWIG_fail;
14939 }
14940 {
14941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14942 }
14943 {
14944 if (created2) delete arg2;
14945 }
14946 {
14947 if (temp3)
14948 delete arg3;
14949 }
14950 return resultobj;
14951 fail:
14952 {
14953 if (created2) delete arg2;
14954 }
14955 {
14956 if (temp3)
14957 delete arg3;
14958 }
14959 return NULL;
14960 }
14961
14962
14963 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14964 PyObject *resultobj = 0;
14965 wxImage *arg1 = (wxImage *) 0 ;
14966 bool result;
14967 void *argp1 = 0 ;
14968 int res1 = 0 ;
14969 PyObject *swig_obj[1] ;
14970
14971 if (!args) SWIG_fail;
14972 swig_obj[0] = args;
14973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14974 if (!SWIG_IsOK(res1)) {
14975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14976 }
14977 arg1 = reinterpret_cast< wxImage * >(argp1);
14978 {
14979 PyThreadState* __tstate = wxPyBeginAllowThreads();
14980 result = (bool)(arg1)->Ok();
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 {
14985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14986 }
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14994 PyObject *resultobj = 0;
14995 wxImage *arg1 = (wxImage *) 0 ;
14996 int result;
14997 void *argp1 = 0 ;
14998 int res1 = 0 ;
14999 PyObject *swig_obj[1] ;
15000
15001 if (!args) SWIG_fail;
15002 swig_obj[0] = args;
15003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15004 if (!SWIG_IsOK(res1)) {
15005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15006 }
15007 arg1 = reinterpret_cast< wxImage * >(argp1);
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 result = (int)(arg1)->GetWidth();
15011 wxPyEndAllowThreads(__tstate);
15012 if (PyErr_Occurred()) SWIG_fail;
15013 }
15014 resultobj = SWIG_From_int(static_cast< int >(result));
15015 return resultobj;
15016 fail:
15017 return NULL;
15018 }
15019
15020
15021 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15022 PyObject *resultobj = 0;
15023 wxImage *arg1 = (wxImage *) 0 ;
15024 int result;
15025 void *argp1 = 0 ;
15026 int res1 = 0 ;
15027 PyObject *swig_obj[1] ;
15028
15029 if (!args) SWIG_fail;
15030 swig_obj[0] = args;
15031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15032 if (!SWIG_IsOK(res1)) {
15033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15034 }
15035 arg1 = reinterpret_cast< wxImage * >(argp1);
15036 {
15037 PyThreadState* __tstate = wxPyBeginAllowThreads();
15038 result = (int)(arg1)->GetHeight();
15039 wxPyEndAllowThreads(__tstate);
15040 if (PyErr_Occurred()) SWIG_fail;
15041 }
15042 resultobj = SWIG_From_int(static_cast< int >(result));
15043 return resultobj;
15044 fail:
15045 return NULL;
15046 }
15047
15048
15049 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15050 PyObject *resultobj = 0;
15051 wxImage *arg1 = (wxImage *) 0 ;
15052 wxSize result;
15053 void *argp1 = 0 ;
15054 int res1 = 0 ;
15055 PyObject *swig_obj[1] ;
15056
15057 if (!args) SWIG_fail;
15058 swig_obj[0] = args;
15059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15060 if (!SWIG_IsOK(res1)) {
15061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15062 }
15063 arg1 = reinterpret_cast< wxImage * >(argp1);
15064 {
15065 PyThreadState* __tstate = wxPyBeginAllowThreads();
15066 result = wxImage_GetSize(arg1);
15067 wxPyEndAllowThreads(__tstate);
15068 if (PyErr_Occurred()) SWIG_fail;
15069 }
15070 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15071 return resultobj;
15072 fail:
15073 return NULL;
15074 }
15075
15076
15077 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15078 PyObject *resultobj = 0;
15079 wxImage *arg1 = (wxImage *) 0 ;
15080 wxRect *arg2 = 0 ;
15081 SwigValueWrapper<wxImage > result;
15082 void *argp1 = 0 ;
15083 int res1 = 0 ;
15084 wxRect temp2 ;
15085 PyObject * obj0 = 0 ;
15086 PyObject * obj1 = 0 ;
15087 char * kwnames[] = {
15088 (char *) "self",(char *) "rect", NULL
15089 };
15090
15091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15093 if (!SWIG_IsOK(res1)) {
15094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15095 }
15096 arg1 = reinterpret_cast< wxImage * >(argp1);
15097 {
15098 arg2 = &temp2;
15099 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15100 }
15101 {
15102 PyThreadState* __tstate = wxPyBeginAllowThreads();
15103 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15104 wxPyEndAllowThreads(__tstate);
15105 if (PyErr_Occurred()) SWIG_fail;
15106 }
15107 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15108 return resultobj;
15109 fail:
15110 return NULL;
15111 }
15112
15113
15114 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15115 PyObject *resultobj = 0;
15116 wxImage *arg1 = (wxImage *) 0 ;
15117 wxSize *arg2 = 0 ;
15118 wxPoint *arg3 = 0 ;
15119 int arg4 = (int) -1 ;
15120 int arg5 = (int) -1 ;
15121 int arg6 = (int) -1 ;
15122 SwigValueWrapper<wxImage > result;
15123 void *argp1 = 0 ;
15124 int res1 = 0 ;
15125 wxSize temp2 ;
15126 wxPoint temp3 ;
15127 int val4 ;
15128 int ecode4 = 0 ;
15129 int val5 ;
15130 int ecode5 = 0 ;
15131 int val6 ;
15132 int ecode6 = 0 ;
15133 PyObject * obj0 = 0 ;
15134 PyObject * obj1 = 0 ;
15135 PyObject * obj2 = 0 ;
15136 PyObject * obj3 = 0 ;
15137 PyObject * obj4 = 0 ;
15138 PyObject * obj5 = 0 ;
15139 char * kwnames[] = {
15140 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15141 };
15142
15143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15145 if (!SWIG_IsOK(res1)) {
15146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15147 }
15148 arg1 = reinterpret_cast< wxImage * >(argp1);
15149 {
15150 arg2 = &temp2;
15151 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15152 }
15153 {
15154 arg3 = &temp3;
15155 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15156 }
15157 if (obj3) {
15158 ecode4 = SWIG_AsVal_int(obj3, &val4);
15159 if (!SWIG_IsOK(ecode4)) {
15160 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15161 }
15162 arg4 = static_cast< int >(val4);
15163 }
15164 if (obj4) {
15165 ecode5 = SWIG_AsVal_int(obj4, &val5);
15166 if (!SWIG_IsOK(ecode5)) {
15167 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15168 }
15169 arg5 = static_cast< int >(val5);
15170 }
15171 if (obj5) {
15172 ecode6 = SWIG_AsVal_int(obj5, &val6);
15173 if (!SWIG_IsOK(ecode6)) {
15174 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15175 }
15176 arg6 = static_cast< int >(val6);
15177 }
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15181 wxPyEndAllowThreads(__tstate);
15182 if (PyErr_Occurred()) SWIG_fail;
15183 }
15184 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15185 return resultobj;
15186 fail:
15187 return NULL;
15188 }
15189
15190
15191 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15192 PyObject *resultobj = 0;
15193 wxImage *arg1 = (wxImage *) 0 ;
15194 SwigValueWrapper<wxImage > result;
15195 void *argp1 = 0 ;
15196 int res1 = 0 ;
15197 PyObject *swig_obj[1] ;
15198
15199 if (!args) SWIG_fail;
15200 swig_obj[0] = args;
15201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15202 if (!SWIG_IsOK(res1)) {
15203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15204 }
15205 arg1 = reinterpret_cast< wxImage * >(argp1);
15206 {
15207 PyThreadState* __tstate = wxPyBeginAllowThreads();
15208 result = (arg1)->Copy();
15209 wxPyEndAllowThreads(__tstate);
15210 if (PyErr_Occurred()) SWIG_fail;
15211 }
15212 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15213 return resultobj;
15214 fail:
15215 return NULL;
15216 }
15217
15218
15219 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj = 0;
15221 wxImage *arg1 = (wxImage *) 0 ;
15222 wxImage *arg2 = 0 ;
15223 int arg3 ;
15224 int arg4 ;
15225 void *argp1 = 0 ;
15226 int res1 = 0 ;
15227 void *argp2 = 0 ;
15228 int res2 = 0 ;
15229 int val3 ;
15230 int ecode3 = 0 ;
15231 int val4 ;
15232 int ecode4 = 0 ;
15233 PyObject * obj0 = 0 ;
15234 PyObject * obj1 = 0 ;
15235 PyObject * obj2 = 0 ;
15236 PyObject * obj3 = 0 ;
15237 char * kwnames[] = {
15238 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15239 };
15240
15241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15243 if (!SWIG_IsOK(res1)) {
15244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15245 }
15246 arg1 = reinterpret_cast< wxImage * >(argp1);
15247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15248 if (!SWIG_IsOK(res2)) {
15249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15250 }
15251 if (!argp2) {
15252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15253 }
15254 arg2 = reinterpret_cast< wxImage * >(argp2);
15255 ecode3 = SWIG_AsVal_int(obj2, &val3);
15256 if (!SWIG_IsOK(ecode3)) {
15257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15258 }
15259 arg3 = static_cast< int >(val3);
15260 ecode4 = SWIG_AsVal_int(obj3, &val4);
15261 if (!SWIG_IsOK(ecode4)) {
15262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15263 }
15264 arg4 = static_cast< int >(val4);
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15268 wxPyEndAllowThreads(__tstate);
15269 if (PyErr_Occurred()) SWIG_fail;
15270 }
15271 resultobj = SWIG_Py_Void();
15272 return resultobj;
15273 fail:
15274 return NULL;
15275 }
15276
15277
15278 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15279 PyObject *resultobj = 0;
15280 wxImage *arg1 = (wxImage *) 0 ;
15281 PyObject *result = 0 ;
15282 void *argp1 = 0 ;
15283 int res1 = 0 ;
15284 PyObject *swig_obj[1] ;
15285
15286 if (!args) SWIG_fail;
15287 swig_obj[0] = args;
15288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15289 if (!SWIG_IsOK(res1)) {
15290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15291 }
15292 arg1 = reinterpret_cast< wxImage * >(argp1);
15293 {
15294 PyThreadState* __tstate = wxPyBeginAllowThreads();
15295 result = (PyObject *)wxImage_GetData(arg1);
15296 wxPyEndAllowThreads(__tstate);
15297 if (PyErr_Occurred()) SWIG_fail;
15298 }
15299 resultobj = result;
15300 return resultobj;
15301 fail:
15302 return NULL;
15303 }
15304
15305
15306 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15307 PyObject *resultobj = 0;
15308 wxImage *arg1 = (wxImage *) 0 ;
15309 buffer arg2 ;
15310 int arg3 ;
15311 void *argp1 = 0 ;
15312 int res1 = 0 ;
15313 PyObject * obj0 = 0 ;
15314 PyObject * obj1 = 0 ;
15315 char * kwnames[] = {
15316 (char *) "self",(char *) "data", NULL
15317 };
15318
15319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15321 if (!SWIG_IsOK(res1)) {
15322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15323 }
15324 arg1 = reinterpret_cast< wxImage * >(argp1);
15325 {
15326 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15327 }
15328 {
15329 PyThreadState* __tstate = wxPyBeginAllowThreads();
15330 wxImage_SetData(arg1,arg2,arg3);
15331 wxPyEndAllowThreads(__tstate);
15332 if (PyErr_Occurred()) SWIG_fail;
15333 }
15334 resultobj = SWIG_Py_Void();
15335 return resultobj;
15336 fail:
15337 return NULL;
15338 }
15339
15340
15341 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15342 PyObject *resultobj = 0;
15343 wxImage *arg1 = (wxImage *) 0 ;
15344 PyObject *result = 0 ;
15345 void *argp1 = 0 ;
15346 int res1 = 0 ;
15347 PyObject *swig_obj[1] ;
15348
15349 if (!args) SWIG_fail;
15350 swig_obj[0] = args;
15351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15352 if (!SWIG_IsOK(res1)) {
15353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15354 }
15355 arg1 = reinterpret_cast< wxImage * >(argp1);
15356 {
15357 PyThreadState* __tstate = wxPyBeginAllowThreads();
15358 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15359 wxPyEndAllowThreads(__tstate);
15360 if (PyErr_Occurred()) SWIG_fail;
15361 }
15362 resultobj = result;
15363 return resultobj;
15364 fail:
15365 return NULL;
15366 }
15367
15368
15369 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15370 PyObject *resultobj = 0;
15371 wxImage *arg1 = (wxImage *) 0 ;
15372 buffer arg2 ;
15373 int arg3 ;
15374 void *argp1 = 0 ;
15375 int res1 = 0 ;
15376 PyObject * obj0 = 0 ;
15377 PyObject * obj1 = 0 ;
15378 char * kwnames[] = {
15379 (char *) "self",(char *) "data", NULL
15380 };
15381
15382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15384 if (!SWIG_IsOK(res1)) {
15385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15386 }
15387 arg1 = reinterpret_cast< wxImage * >(argp1);
15388 {
15389 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15390 }
15391 {
15392 PyThreadState* __tstate = wxPyBeginAllowThreads();
15393 wxImage_SetDataBuffer(arg1,arg2,arg3);
15394 wxPyEndAllowThreads(__tstate);
15395 if (PyErr_Occurred()) SWIG_fail;
15396 }
15397 resultobj = SWIG_Py_Void();
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15405 PyObject *resultobj = 0;
15406 wxImage *arg1 = (wxImage *) 0 ;
15407 PyObject *result = 0 ;
15408 void *argp1 = 0 ;
15409 int res1 = 0 ;
15410 PyObject *swig_obj[1] ;
15411
15412 if (!args) SWIG_fail;
15413 swig_obj[0] = args;
15414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15415 if (!SWIG_IsOK(res1)) {
15416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15417 }
15418 arg1 = reinterpret_cast< wxImage * >(argp1);
15419 {
15420 PyThreadState* __tstate = wxPyBeginAllowThreads();
15421 result = (PyObject *)wxImage_GetAlphaData(arg1);
15422 wxPyEndAllowThreads(__tstate);
15423 if (PyErr_Occurred()) SWIG_fail;
15424 }
15425 resultobj = result;
15426 return resultobj;
15427 fail:
15428 return NULL;
15429 }
15430
15431
15432 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15433 PyObject *resultobj = 0;
15434 wxImage *arg1 = (wxImage *) 0 ;
15435 buffer arg2 ;
15436 int arg3 ;
15437 void *argp1 = 0 ;
15438 int res1 = 0 ;
15439 PyObject * obj0 = 0 ;
15440 PyObject * obj1 = 0 ;
15441 char * kwnames[] = {
15442 (char *) "self",(char *) "alpha", NULL
15443 };
15444
15445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15447 if (!SWIG_IsOK(res1)) {
15448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15449 }
15450 arg1 = reinterpret_cast< wxImage * >(argp1);
15451 {
15452 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15453 }
15454 {
15455 PyThreadState* __tstate = wxPyBeginAllowThreads();
15456 wxImage_SetAlphaData(arg1,arg2,arg3);
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 resultobj = SWIG_Py_Void();
15461 return resultobj;
15462 fail:
15463 return NULL;
15464 }
15465
15466
15467 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15468 PyObject *resultobj = 0;
15469 wxImage *arg1 = (wxImage *) 0 ;
15470 PyObject *result = 0 ;
15471 void *argp1 = 0 ;
15472 int res1 = 0 ;
15473 PyObject *swig_obj[1] ;
15474
15475 if (!args) SWIG_fail;
15476 swig_obj[0] = args;
15477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15478 if (!SWIG_IsOK(res1)) {
15479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15480 }
15481 arg1 = reinterpret_cast< wxImage * >(argp1);
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 resultobj = result;
15489 return resultobj;
15490 fail:
15491 return NULL;
15492 }
15493
15494
15495 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15496 PyObject *resultobj = 0;
15497 wxImage *arg1 = (wxImage *) 0 ;
15498 buffer arg2 ;
15499 int arg3 ;
15500 void *argp1 = 0 ;
15501 int res1 = 0 ;
15502 PyObject * obj0 = 0 ;
15503 PyObject * obj1 = 0 ;
15504 char * kwnames[] = {
15505 (char *) "self",(char *) "alpha", NULL
15506 };
15507
15508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15510 if (!SWIG_IsOK(res1)) {
15511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15512 }
15513 arg1 = reinterpret_cast< wxImage * >(argp1);
15514 {
15515 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15516 }
15517 {
15518 PyThreadState* __tstate = wxPyBeginAllowThreads();
15519 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15520 wxPyEndAllowThreads(__tstate);
15521 if (PyErr_Occurred()) SWIG_fail;
15522 }
15523 resultobj = SWIG_Py_Void();
15524 return resultobj;
15525 fail:
15526 return NULL;
15527 }
15528
15529
15530 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15531 PyObject *resultobj = 0;
15532 wxImage *arg1 = (wxImage *) 0 ;
15533 byte arg2 ;
15534 byte arg3 ;
15535 byte arg4 ;
15536 void *argp1 = 0 ;
15537 int res1 = 0 ;
15538 unsigned char val2 ;
15539 int ecode2 = 0 ;
15540 unsigned char val3 ;
15541 int ecode3 = 0 ;
15542 unsigned char val4 ;
15543 int ecode4 = 0 ;
15544 PyObject * obj0 = 0 ;
15545 PyObject * obj1 = 0 ;
15546 PyObject * obj2 = 0 ;
15547 PyObject * obj3 = 0 ;
15548 char * kwnames[] = {
15549 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15550 };
15551
15552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15554 if (!SWIG_IsOK(res1)) {
15555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15556 }
15557 arg1 = reinterpret_cast< wxImage * >(argp1);
15558 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15559 if (!SWIG_IsOK(ecode2)) {
15560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15561 }
15562 arg2 = static_cast< byte >(val2);
15563 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15564 if (!SWIG_IsOK(ecode3)) {
15565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15566 }
15567 arg3 = static_cast< byte >(val3);
15568 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15569 if (!SWIG_IsOK(ecode4)) {
15570 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15571 }
15572 arg4 = static_cast< byte >(val4);
15573 {
15574 PyThreadState* __tstate = wxPyBeginAllowThreads();
15575 (arg1)->SetMaskColour(arg2,arg3,arg4);
15576 wxPyEndAllowThreads(__tstate);
15577 if (PyErr_Occurred()) SWIG_fail;
15578 }
15579 resultobj = SWIG_Py_Void();
15580 return resultobj;
15581 fail:
15582 return NULL;
15583 }
15584
15585
15586 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15587 PyObject *resultobj = 0;
15588 wxImage *arg1 = (wxImage *) 0 ;
15589 byte *arg2 = (byte *) 0 ;
15590 byte *arg3 = (byte *) 0 ;
15591 byte *arg4 = (byte *) 0 ;
15592 void *argp1 = 0 ;
15593 int res1 = 0 ;
15594 byte temp2 ;
15595 int res2 = SWIG_TMPOBJ ;
15596 byte temp3 ;
15597 int res3 = SWIG_TMPOBJ ;
15598 byte temp4 ;
15599 int res4 = SWIG_TMPOBJ ;
15600 PyObject *swig_obj[1] ;
15601
15602 arg2 = &temp2;
15603 arg3 = &temp3;
15604 arg4 = &temp4;
15605 if (!args) SWIG_fail;
15606 swig_obj[0] = args;
15607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15608 if (!SWIG_IsOK(res1)) {
15609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15610 }
15611 arg1 = reinterpret_cast< wxImage * >(argp1);
15612 {
15613 PyThreadState* __tstate = wxPyBeginAllowThreads();
15614 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15615 wxPyEndAllowThreads(__tstate);
15616 if (PyErr_Occurred()) SWIG_fail;
15617 }
15618 resultobj = SWIG_Py_Void();
15619 if (SWIG_IsTmpObj(res2)) {
15620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15621 } else {
15622 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15624 }
15625 if (SWIG_IsTmpObj(res3)) {
15626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15627 } else {
15628 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15630 }
15631 if (SWIG_IsTmpObj(res4)) {
15632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15633 } else {
15634 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15636 }
15637 return resultobj;
15638 fail:
15639 return NULL;
15640 }
15641
15642
15643 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15644 PyObject *resultobj = 0;
15645 wxImage *arg1 = (wxImage *) 0 ;
15646 byte result;
15647 void *argp1 = 0 ;
15648 int res1 = 0 ;
15649 PyObject *swig_obj[1] ;
15650
15651 if (!args) SWIG_fail;
15652 swig_obj[0] = args;
15653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15654 if (!SWIG_IsOK(res1)) {
15655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15656 }
15657 arg1 = reinterpret_cast< wxImage * >(argp1);
15658 {
15659 PyThreadState* __tstate = wxPyBeginAllowThreads();
15660 result = (byte)(arg1)->GetMaskRed();
15661 wxPyEndAllowThreads(__tstate);
15662 if (PyErr_Occurred()) SWIG_fail;
15663 }
15664 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15665 return resultobj;
15666 fail:
15667 return NULL;
15668 }
15669
15670
15671 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15672 PyObject *resultobj = 0;
15673 wxImage *arg1 = (wxImage *) 0 ;
15674 byte result;
15675 void *argp1 = 0 ;
15676 int res1 = 0 ;
15677 PyObject *swig_obj[1] ;
15678
15679 if (!args) SWIG_fail;
15680 swig_obj[0] = args;
15681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15682 if (!SWIG_IsOK(res1)) {
15683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15684 }
15685 arg1 = reinterpret_cast< wxImage * >(argp1);
15686 {
15687 PyThreadState* __tstate = wxPyBeginAllowThreads();
15688 result = (byte)(arg1)->GetMaskGreen();
15689 wxPyEndAllowThreads(__tstate);
15690 if (PyErr_Occurred()) SWIG_fail;
15691 }
15692 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15693 return resultobj;
15694 fail:
15695 return NULL;
15696 }
15697
15698
15699 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15700 PyObject *resultobj = 0;
15701 wxImage *arg1 = (wxImage *) 0 ;
15702 byte result;
15703 void *argp1 = 0 ;
15704 int res1 = 0 ;
15705 PyObject *swig_obj[1] ;
15706
15707 if (!args) SWIG_fail;
15708 swig_obj[0] = args;
15709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15710 if (!SWIG_IsOK(res1)) {
15711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15712 }
15713 arg1 = reinterpret_cast< wxImage * >(argp1);
15714 {
15715 PyThreadState* __tstate = wxPyBeginAllowThreads();
15716 result = (byte)(arg1)->GetMaskBlue();
15717 wxPyEndAllowThreads(__tstate);
15718 if (PyErr_Occurred()) SWIG_fail;
15719 }
15720 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15721 return resultobj;
15722 fail:
15723 return NULL;
15724 }
15725
15726
15727 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15728 PyObject *resultobj = 0;
15729 wxImage *arg1 = (wxImage *) 0 ;
15730 bool arg2 = (bool) true ;
15731 void *argp1 = 0 ;
15732 int res1 = 0 ;
15733 bool val2 ;
15734 int ecode2 = 0 ;
15735 PyObject * obj0 = 0 ;
15736 PyObject * obj1 = 0 ;
15737 char * kwnames[] = {
15738 (char *) "self",(char *) "mask", NULL
15739 };
15740
15741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15743 if (!SWIG_IsOK(res1)) {
15744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15745 }
15746 arg1 = reinterpret_cast< wxImage * >(argp1);
15747 if (obj1) {
15748 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15749 if (!SWIG_IsOK(ecode2)) {
15750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15751 }
15752 arg2 = static_cast< bool >(val2);
15753 }
15754 {
15755 PyThreadState* __tstate = wxPyBeginAllowThreads();
15756 (arg1)->SetMask(arg2);
15757 wxPyEndAllowThreads(__tstate);
15758 if (PyErr_Occurred()) SWIG_fail;
15759 }
15760 resultobj = SWIG_Py_Void();
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15768 PyObject *resultobj = 0;
15769 wxImage *arg1 = (wxImage *) 0 ;
15770 bool result;
15771 void *argp1 = 0 ;
15772 int res1 = 0 ;
15773 PyObject *swig_obj[1] ;
15774
15775 if (!args) SWIG_fail;
15776 swig_obj[0] = args;
15777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15778 if (!SWIG_IsOK(res1)) {
15779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15780 }
15781 arg1 = reinterpret_cast< wxImage * >(argp1);
15782 {
15783 PyThreadState* __tstate = wxPyBeginAllowThreads();
15784 result = (bool)(arg1)->HasMask();
15785 wxPyEndAllowThreads(__tstate);
15786 if (PyErr_Occurred()) SWIG_fail;
15787 }
15788 {
15789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15790 }
15791 return resultobj;
15792 fail:
15793 return NULL;
15794 }
15795
15796
15797 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15798 PyObject *resultobj = 0;
15799 wxImage *arg1 = (wxImage *) 0 ;
15800 double arg2 ;
15801 wxPoint *arg3 = 0 ;
15802 bool arg4 = (bool) true ;
15803 wxPoint *arg5 = (wxPoint *) NULL ;
15804 SwigValueWrapper<wxImage > result;
15805 void *argp1 = 0 ;
15806 int res1 = 0 ;
15807 double val2 ;
15808 int ecode2 = 0 ;
15809 wxPoint temp3 ;
15810 bool val4 ;
15811 int ecode4 = 0 ;
15812 void *argp5 = 0 ;
15813 int res5 = 0 ;
15814 PyObject * obj0 = 0 ;
15815 PyObject * obj1 = 0 ;
15816 PyObject * obj2 = 0 ;
15817 PyObject * obj3 = 0 ;
15818 PyObject * obj4 = 0 ;
15819 char * kwnames[] = {
15820 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15821 };
15822
15823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15825 if (!SWIG_IsOK(res1)) {
15826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15827 }
15828 arg1 = reinterpret_cast< wxImage * >(argp1);
15829 ecode2 = SWIG_AsVal_double(obj1, &val2);
15830 if (!SWIG_IsOK(ecode2)) {
15831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15832 }
15833 arg2 = static_cast< double >(val2);
15834 {
15835 arg3 = &temp3;
15836 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15837 }
15838 if (obj3) {
15839 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15840 if (!SWIG_IsOK(ecode4)) {
15841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15842 }
15843 arg4 = static_cast< bool >(val4);
15844 }
15845 if (obj4) {
15846 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15847 if (!SWIG_IsOK(res5)) {
15848 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15849 }
15850 arg5 = reinterpret_cast< wxPoint * >(argp5);
15851 }
15852 {
15853 PyThreadState* __tstate = wxPyBeginAllowThreads();
15854 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15859 return resultobj;
15860 fail:
15861 return NULL;
15862 }
15863
15864
15865 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15866 PyObject *resultobj = 0;
15867 wxImage *arg1 = (wxImage *) 0 ;
15868 bool arg2 = (bool) true ;
15869 SwigValueWrapper<wxImage > result;
15870 void *argp1 = 0 ;
15871 int res1 = 0 ;
15872 bool val2 ;
15873 int ecode2 = 0 ;
15874 PyObject * obj0 = 0 ;
15875 PyObject * obj1 = 0 ;
15876 char * kwnames[] = {
15877 (char *) "self",(char *) "clockwise", NULL
15878 };
15879
15880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15882 if (!SWIG_IsOK(res1)) {
15883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15884 }
15885 arg1 = reinterpret_cast< wxImage * >(argp1);
15886 if (obj1) {
15887 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15888 if (!SWIG_IsOK(ecode2)) {
15889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15890 }
15891 arg2 = static_cast< bool >(val2);
15892 }
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (arg1)->Rotate90(arg2);
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15900 return resultobj;
15901 fail:
15902 return NULL;
15903 }
15904
15905
15906 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15907 PyObject *resultobj = 0;
15908 wxImage *arg1 = (wxImage *) 0 ;
15909 bool arg2 = (bool) true ;
15910 SwigValueWrapper<wxImage > result;
15911 void *argp1 = 0 ;
15912 int res1 = 0 ;
15913 bool val2 ;
15914 int ecode2 = 0 ;
15915 PyObject * obj0 = 0 ;
15916 PyObject * obj1 = 0 ;
15917 char * kwnames[] = {
15918 (char *) "self",(char *) "horizontally", NULL
15919 };
15920
15921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15923 if (!SWIG_IsOK(res1)) {
15924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15925 }
15926 arg1 = reinterpret_cast< wxImage * >(argp1);
15927 if (obj1) {
15928 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15929 if (!SWIG_IsOK(ecode2)) {
15930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15931 }
15932 arg2 = static_cast< bool >(val2);
15933 }
15934 {
15935 PyThreadState* __tstate = wxPyBeginAllowThreads();
15936 result = (arg1)->Mirror(arg2);
15937 wxPyEndAllowThreads(__tstate);
15938 if (PyErr_Occurred()) SWIG_fail;
15939 }
15940 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15941 return resultobj;
15942 fail:
15943 return NULL;
15944 }
15945
15946
15947 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15948 PyObject *resultobj = 0;
15949 wxImage *arg1 = (wxImage *) 0 ;
15950 byte arg2 ;
15951 byte arg3 ;
15952 byte arg4 ;
15953 byte arg5 ;
15954 byte arg6 ;
15955 byte arg7 ;
15956 void *argp1 = 0 ;
15957 int res1 = 0 ;
15958 unsigned char val2 ;
15959 int ecode2 = 0 ;
15960 unsigned char val3 ;
15961 int ecode3 = 0 ;
15962 unsigned char val4 ;
15963 int ecode4 = 0 ;
15964 unsigned char val5 ;
15965 int ecode5 = 0 ;
15966 unsigned char val6 ;
15967 int ecode6 = 0 ;
15968 unsigned char val7 ;
15969 int ecode7 = 0 ;
15970 PyObject * obj0 = 0 ;
15971 PyObject * obj1 = 0 ;
15972 PyObject * obj2 = 0 ;
15973 PyObject * obj3 = 0 ;
15974 PyObject * obj4 = 0 ;
15975 PyObject * obj5 = 0 ;
15976 PyObject * obj6 = 0 ;
15977 char * kwnames[] = {
15978 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15979 };
15980
15981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15983 if (!SWIG_IsOK(res1)) {
15984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15985 }
15986 arg1 = reinterpret_cast< wxImage * >(argp1);
15987 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15988 if (!SWIG_IsOK(ecode2)) {
15989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15990 }
15991 arg2 = static_cast< byte >(val2);
15992 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15993 if (!SWIG_IsOK(ecode3)) {
15994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15995 }
15996 arg3 = static_cast< byte >(val3);
15997 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15998 if (!SWIG_IsOK(ecode4)) {
15999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16000 }
16001 arg4 = static_cast< byte >(val4);
16002 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16003 if (!SWIG_IsOK(ecode5)) {
16004 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16005 }
16006 arg5 = static_cast< byte >(val5);
16007 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16008 if (!SWIG_IsOK(ecode6)) {
16009 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16010 }
16011 arg6 = static_cast< byte >(val6);
16012 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16013 if (!SWIG_IsOK(ecode7)) {
16014 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16015 }
16016 arg7 = static_cast< byte >(val7);
16017 {
16018 PyThreadState* __tstate = wxPyBeginAllowThreads();
16019 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16020 wxPyEndAllowThreads(__tstate);
16021 if (PyErr_Occurred()) SWIG_fail;
16022 }
16023 resultobj = SWIG_Py_Void();
16024 return resultobj;
16025 fail:
16026 return NULL;
16027 }
16028
16029
16030 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16031 PyObject *resultobj = 0;
16032 wxImage *arg1 = (wxImage *) 0 ;
16033 double arg2 = (double) 0.299 ;
16034 double arg3 = (double) 0.587 ;
16035 double arg4 = (double) 0.114 ;
16036 SwigValueWrapper<wxImage > result;
16037 void *argp1 = 0 ;
16038 int res1 = 0 ;
16039 double val2 ;
16040 int ecode2 = 0 ;
16041 double val3 ;
16042 int ecode3 = 0 ;
16043 double val4 ;
16044 int ecode4 = 0 ;
16045 PyObject * obj0 = 0 ;
16046 PyObject * obj1 = 0 ;
16047 PyObject * obj2 = 0 ;
16048 PyObject * obj3 = 0 ;
16049 char * kwnames[] = {
16050 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16051 };
16052
16053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16055 if (!SWIG_IsOK(res1)) {
16056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16057 }
16058 arg1 = reinterpret_cast< wxImage * >(argp1);
16059 if (obj1) {
16060 ecode2 = SWIG_AsVal_double(obj1, &val2);
16061 if (!SWIG_IsOK(ecode2)) {
16062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16063 }
16064 arg2 = static_cast< double >(val2);
16065 }
16066 if (obj2) {
16067 ecode3 = SWIG_AsVal_double(obj2, &val3);
16068 if (!SWIG_IsOK(ecode3)) {
16069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16070 }
16071 arg3 = static_cast< double >(val3);
16072 }
16073 if (obj3) {
16074 ecode4 = SWIG_AsVal_double(obj3, &val4);
16075 if (!SWIG_IsOK(ecode4)) {
16076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16077 }
16078 arg4 = static_cast< double >(val4);
16079 }
16080 {
16081 PyThreadState* __tstate = wxPyBeginAllowThreads();
16082 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16083 wxPyEndAllowThreads(__tstate);
16084 if (PyErr_Occurred()) SWIG_fail;
16085 }
16086 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16087 return resultobj;
16088 fail:
16089 return NULL;
16090 }
16091
16092
16093 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16094 PyObject *resultobj = 0;
16095 wxImage *arg1 = (wxImage *) 0 ;
16096 byte arg2 ;
16097 byte arg3 ;
16098 byte arg4 ;
16099 SwigValueWrapper<wxImage > result;
16100 void *argp1 = 0 ;
16101 int res1 = 0 ;
16102 unsigned char val2 ;
16103 int ecode2 = 0 ;
16104 unsigned char val3 ;
16105 int ecode3 = 0 ;
16106 unsigned char val4 ;
16107 int ecode4 = 0 ;
16108 PyObject * obj0 = 0 ;
16109 PyObject * obj1 = 0 ;
16110 PyObject * obj2 = 0 ;
16111 PyObject * obj3 = 0 ;
16112 char * kwnames[] = {
16113 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16114 };
16115
16116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16118 if (!SWIG_IsOK(res1)) {
16119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16120 }
16121 arg1 = reinterpret_cast< wxImage * >(argp1);
16122 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16123 if (!SWIG_IsOK(ecode2)) {
16124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16125 }
16126 arg2 = static_cast< byte >(val2);
16127 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16128 if (!SWIG_IsOK(ecode3)) {
16129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16130 }
16131 arg3 = static_cast< byte >(val3);
16132 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16133 if (!SWIG_IsOK(ecode4)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16135 }
16136 arg4 = static_cast< byte >(val4);
16137 {
16138 PyThreadState* __tstate = wxPyBeginAllowThreads();
16139 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16140 wxPyEndAllowThreads(__tstate);
16141 if (PyErr_Occurred()) SWIG_fail;
16142 }
16143 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj = 0;
16152 wxImage *arg1 = (wxImage *) 0 ;
16153 wxString *arg2 = 0 ;
16154 wxString *arg3 = 0 ;
16155 void *argp1 = 0 ;
16156 int res1 = 0 ;
16157 bool temp2 = false ;
16158 bool temp3 = false ;
16159 PyObject * obj0 = 0 ;
16160 PyObject * obj1 = 0 ;
16161 PyObject * obj2 = 0 ;
16162 char * kwnames[] = {
16163 (char *) "self",(char *) "name",(char *) "value", NULL
16164 };
16165
16166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16168 if (!SWIG_IsOK(res1)) {
16169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16170 }
16171 arg1 = reinterpret_cast< wxImage * >(argp1);
16172 {
16173 arg2 = wxString_in_helper(obj1);
16174 if (arg2 == NULL) SWIG_fail;
16175 temp2 = true;
16176 }
16177 {
16178 arg3 = wxString_in_helper(obj2);
16179 if (arg3 == NULL) SWIG_fail;
16180 temp3 = true;
16181 }
16182 {
16183 PyThreadState* __tstate = wxPyBeginAllowThreads();
16184 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16185 wxPyEndAllowThreads(__tstate);
16186 if (PyErr_Occurred()) SWIG_fail;
16187 }
16188 resultobj = SWIG_Py_Void();
16189 {
16190 if (temp2)
16191 delete arg2;
16192 }
16193 {
16194 if (temp3)
16195 delete arg3;
16196 }
16197 return resultobj;
16198 fail:
16199 {
16200 if (temp2)
16201 delete arg2;
16202 }
16203 {
16204 if (temp3)
16205 delete arg3;
16206 }
16207 return NULL;
16208 }
16209
16210
16211 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16212 PyObject *resultobj = 0;
16213 wxImage *arg1 = (wxImage *) 0 ;
16214 wxString *arg2 = 0 ;
16215 int arg3 ;
16216 void *argp1 = 0 ;
16217 int res1 = 0 ;
16218 bool temp2 = false ;
16219 int val3 ;
16220 int ecode3 = 0 ;
16221 PyObject * obj0 = 0 ;
16222 PyObject * obj1 = 0 ;
16223 PyObject * obj2 = 0 ;
16224 char * kwnames[] = {
16225 (char *) "self",(char *) "name",(char *) "value", NULL
16226 };
16227
16228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16230 if (!SWIG_IsOK(res1)) {
16231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16232 }
16233 arg1 = reinterpret_cast< wxImage * >(argp1);
16234 {
16235 arg2 = wxString_in_helper(obj1);
16236 if (arg2 == NULL) SWIG_fail;
16237 temp2 = true;
16238 }
16239 ecode3 = SWIG_AsVal_int(obj2, &val3);
16240 if (!SWIG_IsOK(ecode3)) {
16241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16242 }
16243 arg3 = static_cast< int >(val3);
16244 {
16245 PyThreadState* __tstate = wxPyBeginAllowThreads();
16246 (arg1)->SetOption((wxString const &)*arg2,arg3);
16247 wxPyEndAllowThreads(__tstate);
16248 if (PyErr_Occurred()) SWIG_fail;
16249 }
16250 resultobj = SWIG_Py_Void();
16251 {
16252 if (temp2)
16253 delete arg2;
16254 }
16255 return resultobj;
16256 fail:
16257 {
16258 if (temp2)
16259 delete arg2;
16260 }
16261 return NULL;
16262 }
16263
16264
16265 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16266 PyObject *resultobj = 0;
16267 wxImage *arg1 = (wxImage *) 0 ;
16268 wxString *arg2 = 0 ;
16269 wxString result;
16270 void *argp1 = 0 ;
16271 int res1 = 0 ;
16272 bool temp2 = false ;
16273 PyObject * obj0 = 0 ;
16274 PyObject * obj1 = 0 ;
16275 char * kwnames[] = {
16276 (char *) "self",(char *) "name", NULL
16277 };
16278
16279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16281 if (!SWIG_IsOK(res1)) {
16282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16283 }
16284 arg1 = reinterpret_cast< wxImage * >(argp1);
16285 {
16286 arg2 = wxString_in_helper(obj1);
16287 if (arg2 == NULL) SWIG_fail;
16288 temp2 = true;
16289 }
16290 {
16291 PyThreadState* __tstate = wxPyBeginAllowThreads();
16292 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16293 wxPyEndAllowThreads(__tstate);
16294 if (PyErr_Occurred()) SWIG_fail;
16295 }
16296 {
16297 #if wxUSE_UNICODE
16298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16299 #else
16300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16301 #endif
16302 }
16303 {
16304 if (temp2)
16305 delete arg2;
16306 }
16307 return resultobj;
16308 fail:
16309 {
16310 if (temp2)
16311 delete arg2;
16312 }
16313 return NULL;
16314 }
16315
16316
16317 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj = 0;
16319 wxImage *arg1 = (wxImage *) 0 ;
16320 wxString *arg2 = 0 ;
16321 int result;
16322 void *argp1 = 0 ;
16323 int res1 = 0 ;
16324 bool temp2 = false ;
16325 PyObject * obj0 = 0 ;
16326 PyObject * obj1 = 0 ;
16327 char * kwnames[] = {
16328 (char *) "self",(char *) "name", NULL
16329 };
16330
16331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16333 if (!SWIG_IsOK(res1)) {
16334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16335 }
16336 arg1 = reinterpret_cast< wxImage * >(argp1);
16337 {
16338 arg2 = wxString_in_helper(obj1);
16339 if (arg2 == NULL) SWIG_fail;
16340 temp2 = true;
16341 }
16342 {
16343 PyThreadState* __tstate = wxPyBeginAllowThreads();
16344 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16345 wxPyEndAllowThreads(__tstate);
16346 if (PyErr_Occurred()) SWIG_fail;
16347 }
16348 resultobj = SWIG_From_int(static_cast< int >(result));
16349 {
16350 if (temp2)
16351 delete arg2;
16352 }
16353 return resultobj;
16354 fail:
16355 {
16356 if (temp2)
16357 delete arg2;
16358 }
16359 return NULL;
16360 }
16361
16362
16363 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16364 PyObject *resultobj = 0;
16365 wxImage *arg1 = (wxImage *) 0 ;
16366 wxString *arg2 = 0 ;
16367 bool result;
16368 void *argp1 = 0 ;
16369 int res1 = 0 ;
16370 bool temp2 = false ;
16371 PyObject * obj0 = 0 ;
16372 PyObject * obj1 = 0 ;
16373 char * kwnames[] = {
16374 (char *) "self",(char *) "name", NULL
16375 };
16376
16377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16379 if (!SWIG_IsOK(res1)) {
16380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16381 }
16382 arg1 = reinterpret_cast< wxImage * >(argp1);
16383 {
16384 arg2 = wxString_in_helper(obj1);
16385 if (arg2 == NULL) SWIG_fail;
16386 temp2 = true;
16387 }
16388 {
16389 PyThreadState* __tstate = wxPyBeginAllowThreads();
16390 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16391 wxPyEndAllowThreads(__tstate);
16392 if (PyErr_Occurred()) SWIG_fail;
16393 }
16394 {
16395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16396 }
16397 {
16398 if (temp2)
16399 delete arg2;
16400 }
16401 return resultobj;
16402 fail:
16403 {
16404 if (temp2)
16405 delete arg2;
16406 }
16407 return NULL;
16408 }
16409
16410
16411 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16412 PyObject *resultobj = 0;
16413 wxImage *arg1 = (wxImage *) 0 ;
16414 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16415 unsigned long result;
16416 void *argp1 = 0 ;
16417 int res1 = 0 ;
16418 unsigned long val2 ;
16419 int ecode2 = 0 ;
16420 PyObject * obj0 = 0 ;
16421 PyObject * obj1 = 0 ;
16422 char * kwnames[] = {
16423 (char *) "self",(char *) "stopafter", NULL
16424 };
16425
16426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16428 if (!SWIG_IsOK(res1)) {
16429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16430 }
16431 arg1 = reinterpret_cast< wxImage * >(argp1);
16432 if (obj1) {
16433 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16434 if (!SWIG_IsOK(ecode2)) {
16435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16436 }
16437 arg2 = static_cast< unsigned long >(val2);
16438 }
16439 {
16440 PyThreadState* __tstate = wxPyBeginAllowThreads();
16441 result = (unsigned long)(arg1)->CountColours(arg2);
16442 wxPyEndAllowThreads(__tstate);
16443 if (PyErr_Occurred()) SWIG_fail;
16444 }
16445 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16446 return resultobj;
16447 fail:
16448 return NULL;
16449 }
16450
16451
16452 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16453 PyObject *resultobj = 0;
16454 wxImage *arg1 = (wxImage *) 0 ;
16455 wxImageHistogram *arg2 = 0 ;
16456 unsigned long result;
16457 void *argp1 = 0 ;
16458 int res1 = 0 ;
16459 void *argp2 = 0 ;
16460 int res2 = 0 ;
16461 PyObject * obj0 = 0 ;
16462 PyObject * obj1 = 0 ;
16463 char * kwnames[] = {
16464 (char *) "self",(char *) "h", NULL
16465 };
16466
16467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16469 if (!SWIG_IsOK(res1)) {
16470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16471 }
16472 arg1 = reinterpret_cast< wxImage * >(argp1);
16473 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16474 if (!SWIG_IsOK(res2)) {
16475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16476 }
16477 if (!argp2) {
16478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16479 }
16480 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16481 {
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16484 wxPyEndAllowThreads(__tstate);
16485 if (PyErr_Occurred()) SWIG_fail;
16486 }
16487 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16488 return resultobj;
16489 fail:
16490 return NULL;
16491 }
16492
16493
16494 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16495 PyObject *resultobj = 0;
16496 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16497 void *argp1 = 0 ;
16498 int res1 = 0 ;
16499 PyObject * obj0 = 0 ;
16500 char * kwnames[] = {
16501 (char *) "handler", NULL
16502 };
16503
16504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16506 if (!SWIG_IsOK(res1)) {
16507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16508 }
16509 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 wxImage::AddHandler(arg1);
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 resultobj = SWIG_Py_Void();
16517 return resultobj;
16518 fail:
16519 return NULL;
16520 }
16521
16522
16523 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16524 PyObject *resultobj = 0;
16525 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16526 void *argp1 = 0 ;
16527 int res1 = 0 ;
16528 PyObject * obj0 = 0 ;
16529 char * kwnames[] = {
16530 (char *) "handler", NULL
16531 };
16532
16533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16535 if (!SWIG_IsOK(res1)) {
16536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16537 }
16538 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16539 {
16540 PyThreadState* __tstate = wxPyBeginAllowThreads();
16541 wxImage::InsertHandler(arg1);
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 resultobj = SWIG_Py_Void();
16546 return resultobj;
16547 fail:
16548 return NULL;
16549 }
16550
16551
16552 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16553 PyObject *resultobj = 0;
16554 wxString *arg1 = 0 ;
16555 bool result;
16556 bool temp1 = false ;
16557 PyObject * obj0 = 0 ;
16558 char * kwnames[] = {
16559 (char *) "name", NULL
16560 };
16561
16562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16563 {
16564 arg1 = wxString_in_helper(obj0);
16565 if (arg1 == NULL) SWIG_fail;
16566 temp1 = true;
16567 }
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 {
16575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16576 }
16577 {
16578 if (temp1)
16579 delete arg1;
16580 }
16581 return resultobj;
16582 fail:
16583 {
16584 if (temp1)
16585 delete arg1;
16586 }
16587 return NULL;
16588 }
16589
16590
16591 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16592 PyObject *resultobj = 0;
16593 PyObject *result = 0 ;
16594
16595 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = (PyObject *)wxImage_GetHandlers();
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 resultobj = result;
16603 return resultobj;
16604 fail:
16605 return NULL;
16606 }
16607
16608
16609 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16610 PyObject *resultobj = 0;
16611 wxString result;
16612
16613 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16614 {
16615 PyThreadState* __tstate = wxPyBeginAllowThreads();
16616 result = wxImage::GetImageExtWildcard();
16617 wxPyEndAllowThreads(__tstate);
16618 if (PyErr_Occurred()) SWIG_fail;
16619 }
16620 {
16621 #if wxUSE_UNICODE
16622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16623 #else
16624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16625 #endif
16626 }
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16634 PyObject *resultobj = 0;
16635 wxImage *arg1 = (wxImage *) 0 ;
16636 int arg2 = (int) -1 ;
16637 wxBitmap result;
16638 void *argp1 = 0 ;
16639 int res1 = 0 ;
16640 int val2 ;
16641 int ecode2 = 0 ;
16642 PyObject * obj0 = 0 ;
16643 PyObject * obj1 = 0 ;
16644 char * kwnames[] = {
16645 (char *) "self",(char *) "depth", NULL
16646 };
16647
16648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16650 if (!SWIG_IsOK(res1)) {
16651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16652 }
16653 arg1 = reinterpret_cast< wxImage * >(argp1);
16654 if (obj1) {
16655 ecode2 = SWIG_AsVal_int(obj1, &val2);
16656 if (!SWIG_IsOK(ecode2)) {
16657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16658 }
16659 arg2 = static_cast< int >(val2);
16660 }
16661 {
16662 if (!wxPyCheckForApp()) SWIG_fail;
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = wxImage_ConvertToBitmap(arg1,arg2);
16665 wxPyEndAllowThreads(__tstate);
16666 if (PyErr_Occurred()) SWIG_fail;
16667 }
16668 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16669 return resultobj;
16670 fail:
16671 return NULL;
16672 }
16673
16674
16675 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16676 PyObject *resultobj = 0;
16677 wxImage *arg1 = (wxImage *) 0 ;
16678 byte arg2 ;
16679 byte arg3 ;
16680 byte arg4 ;
16681 wxBitmap result;
16682 void *argp1 = 0 ;
16683 int res1 = 0 ;
16684 unsigned char val2 ;
16685 int ecode2 = 0 ;
16686 unsigned char val3 ;
16687 int ecode3 = 0 ;
16688 unsigned char val4 ;
16689 int ecode4 = 0 ;
16690 PyObject * obj0 = 0 ;
16691 PyObject * obj1 = 0 ;
16692 PyObject * obj2 = 0 ;
16693 PyObject * obj3 = 0 ;
16694 char * kwnames[] = {
16695 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16696 };
16697
16698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16700 if (!SWIG_IsOK(res1)) {
16701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16702 }
16703 arg1 = reinterpret_cast< wxImage * >(argp1);
16704 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16705 if (!SWIG_IsOK(ecode2)) {
16706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16707 }
16708 arg2 = static_cast< byte >(val2);
16709 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16710 if (!SWIG_IsOK(ecode3)) {
16711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16712 }
16713 arg3 = static_cast< byte >(val3);
16714 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16715 if (!SWIG_IsOK(ecode4)) {
16716 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16717 }
16718 arg4 = static_cast< byte >(val4);
16719 {
16720 if (!wxPyCheckForApp()) SWIG_fail;
16721 PyThreadState* __tstate = wxPyBeginAllowThreads();
16722 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16727 return resultobj;
16728 fail:
16729 return NULL;
16730 }
16731
16732
16733 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16734 PyObject *resultobj = 0;
16735 wxImage *arg1 = (wxImage *) 0 ;
16736 double arg2 ;
16737 void *argp1 = 0 ;
16738 int res1 = 0 ;
16739 double val2 ;
16740 int ecode2 = 0 ;
16741 PyObject * obj0 = 0 ;
16742 PyObject * obj1 = 0 ;
16743 char * kwnames[] = {
16744 (char *) "self",(char *) "angle", NULL
16745 };
16746
16747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16749 if (!SWIG_IsOK(res1)) {
16750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16751 }
16752 arg1 = reinterpret_cast< wxImage * >(argp1);
16753 ecode2 = SWIG_AsVal_double(obj1, &val2);
16754 if (!SWIG_IsOK(ecode2)) {
16755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16756 }
16757 arg2 = static_cast< double >(val2);
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 (arg1)->RotateHue(arg2);
16761 wxPyEndAllowThreads(__tstate);
16762 if (PyErr_Occurred()) SWIG_fail;
16763 }
16764 resultobj = SWIG_Py_Void();
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16772 PyObject *resultobj = 0;
16773 wxImage_RGBValue arg1 ;
16774 wxImage_HSVValue result;
16775 void *argp1 ;
16776 int res1 = 0 ;
16777 PyObject * obj0 = 0 ;
16778 char * kwnames[] = {
16779 (char *) "rgb", NULL
16780 };
16781
16782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16783 {
16784 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16785 if (!SWIG_IsOK(res1)) {
16786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16787 }
16788 if (!argp1) {
16789 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16790 } else {
16791 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16792 arg1 = *temp;
16793 if (SWIG_IsNewObj(res1)) delete temp;
16794 }
16795 }
16796 {
16797 PyThreadState* __tstate = wxPyBeginAllowThreads();
16798 result = wxImage::RGBtoHSV(arg1);
16799 wxPyEndAllowThreads(__tstate);
16800 if (PyErr_Occurred()) SWIG_fail;
16801 }
16802 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16803 return resultobj;
16804 fail:
16805 return NULL;
16806 }
16807
16808
16809 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16810 PyObject *resultobj = 0;
16811 wxImage_HSVValue arg1 ;
16812 wxImage_RGBValue result;
16813 void *argp1 ;
16814 int res1 = 0 ;
16815 PyObject * obj0 = 0 ;
16816 char * kwnames[] = {
16817 (char *) "hsv", NULL
16818 };
16819
16820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16821 {
16822 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16823 if (!SWIG_IsOK(res1)) {
16824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16825 }
16826 if (!argp1) {
16827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16828 } else {
16829 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16830 arg1 = *temp;
16831 if (SWIG_IsNewObj(res1)) delete temp;
16832 }
16833 }
16834 {
16835 PyThreadState* __tstate = wxPyBeginAllowThreads();
16836 result = wxImage::HSVtoRGB(arg1);
16837 wxPyEndAllowThreads(__tstate);
16838 if (PyErr_Occurred()) SWIG_fail;
16839 }
16840 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16841 return resultobj;
16842 fail:
16843 return NULL;
16844 }
16845
16846
16847 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16848 PyObject *obj;
16849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16850 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16851 return SWIG_Py_Void();
16852 }
16853
16854 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16855 return SWIG_Python_InitShadowInstance(args);
16856 }
16857
16858 SWIGINTERN int NullImage_set(PyObject *) {
16859 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16860 return 1;
16861 }
16862
16863
16864 SWIGINTERN PyObject *NullImage_get(void) {
16865 PyObject *pyobj = 0;
16866
16867 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16868 return pyobj;
16869 }
16870
16871
16872 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16873 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16874 return 1;
16875 }
16876
16877
16878 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16879 PyObject *pyobj = 0;
16880
16881 {
16882 #if wxUSE_UNICODE
16883 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16884 #else
16885 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16886 #endif
16887 }
16888 return pyobj;
16889 }
16890
16891
16892 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16893 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16894 return 1;
16895 }
16896
16897
16898 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16899 PyObject *pyobj = 0;
16900
16901 {
16902 #if wxUSE_UNICODE
16903 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16904 #else
16905 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16906 #endif
16907 }
16908 return pyobj;
16909 }
16910
16911
16912 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16913 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16914 return 1;
16915 }
16916
16917
16918 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16919 PyObject *pyobj = 0;
16920
16921 {
16922 #if wxUSE_UNICODE
16923 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16924 #else
16925 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16926 #endif
16927 }
16928 return pyobj;
16929 }
16930
16931
16932 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16933 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16934 return 1;
16935 }
16936
16937
16938 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16939 PyObject *pyobj = 0;
16940
16941 {
16942 #if wxUSE_UNICODE
16943 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16944 #else
16945 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16946 #endif
16947 }
16948 return pyobj;
16949 }
16950
16951
16952 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16953 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16954 return 1;
16955 }
16956
16957
16958 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16959 PyObject *pyobj = 0;
16960
16961 {
16962 #if wxUSE_UNICODE
16963 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16964 #else
16965 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16966 #endif
16967 }
16968 return pyobj;
16969 }
16970
16971
16972 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16973 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16974 return 1;
16975 }
16976
16977
16978 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16979 PyObject *pyobj = 0;
16980
16981 {
16982 #if wxUSE_UNICODE
16983 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16984 #else
16985 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16986 #endif
16987 }
16988 return pyobj;
16989 }
16990
16991
16992 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16993 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16994 return 1;
16995 }
16996
16997
16998 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16999 PyObject *pyobj = 0;
17000
17001 {
17002 #if wxUSE_UNICODE
17003 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17004 #else
17005 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17006 #endif
17007 }
17008 return pyobj;
17009 }
17010
17011
17012 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17013 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17014 return 1;
17015 }
17016
17017
17018 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17019 PyObject *pyobj = 0;
17020
17021 {
17022 #if wxUSE_UNICODE
17023 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17024 #else
17025 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17026 #endif
17027 }
17028 return pyobj;
17029 }
17030
17031
17032 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17033 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17034 return 1;
17035 }
17036
17037
17038 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17039 PyObject *pyobj = 0;
17040
17041 {
17042 #if wxUSE_UNICODE
17043 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17044 #else
17045 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17046 #endif
17047 }
17048 return pyobj;
17049 }
17050
17051
17052 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17053 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17054 return 1;
17055 }
17056
17057
17058 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17059 PyObject *pyobj = 0;
17060
17061 {
17062 #if wxUSE_UNICODE
17063 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17064 #else
17065 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17066 #endif
17067 }
17068 return pyobj;
17069 }
17070
17071
17072 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17073 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17074 return 1;
17075 }
17076
17077
17078 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17079 PyObject *pyobj = 0;
17080
17081 {
17082 #if wxUSE_UNICODE
17083 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17084 #else
17085 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17086 #endif
17087 }
17088 return pyobj;
17089 }
17090
17091
17092 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17093 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17094 return 1;
17095 }
17096
17097
17098 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17099 PyObject *pyobj = 0;
17100
17101 {
17102 #if wxUSE_UNICODE
17103 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17104 #else
17105 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17106 #endif
17107 }
17108 return pyobj;
17109 }
17110
17111
17112 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17113 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17114 return 1;
17115 }
17116
17117
17118 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17119 PyObject *pyobj = 0;
17120
17121 {
17122 #if wxUSE_UNICODE
17123 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17124 #else
17125 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17126 #endif
17127 }
17128 return pyobj;
17129 }
17130
17131
17132 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17133 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17134 return 1;
17135 }
17136
17137
17138 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17139 PyObject *pyobj = 0;
17140
17141 {
17142 #if wxUSE_UNICODE
17143 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17144 #else
17145 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17146 #endif
17147 }
17148 return pyobj;
17149 }
17150
17151
17152 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17153 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17154 return 1;
17155 }
17156
17157
17158 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17159 PyObject *pyobj = 0;
17160
17161 {
17162 #if wxUSE_UNICODE
17163 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17164 #else
17165 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17166 #endif
17167 }
17168 return pyobj;
17169 }
17170
17171
17172 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17173 PyObject *resultobj = 0;
17174 wxBMPHandler *result = 0 ;
17175
17176 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17177 {
17178 PyThreadState* __tstate = wxPyBeginAllowThreads();
17179 result = (wxBMPHandler *)new wxBMPHandler();
17180 wxPyEndAllowThreads(__tstate);
17181 if (PyErr_Occurred()) SWIG_fail;
17182 }
17183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17184 return resultobj;
17185 fail:
17186 return NULL;
17187 }
17188
17189
17190 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17191 PyObject *obj;
17192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17193 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17194 return SWIG_Py_Void();
17195 }
17196
17197 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17198 return SWIG_Python_InitShadowInstance(args);
17199 }
17200
17201 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17202 PyObject *resultobj = 0;
17203 wxICOHandler *result = 0 ;
17204
17205 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17206 {
17207 PyThreadState* __tstate = wxPyBeginAllowThreads();
17208 result = (wxICOHandler *)new wxICOHandler();
17209 wxPyEndAllowThreads(__tstate);
17210 if (PyErr_Occurred()) SWIG_fail;
17211 }
17212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17213 return resultobj;
17214 fail:
17215 return NULL;
17216 }
17217
17218
17219 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17220 PyObject *obj;
17221 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17222 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17223 return SWIG_Py_Void();
17224 }
17225
17226 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17227 return SWIG_Python_InitShadowInstance(args);
17228 }
17229
17230 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17231 PyObject *resultobj = 0;
17232 wxCURHandler *result = 0 ;
17233
17234 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17235 {
17236 PyThreadState* __tstate = wxPyBeginAllowThreads();
17237 result = (wxCURHandler *)new wxCURHandler();
17238 wxPyEndAllowThreads(__tstate);
17239 if (PyErr_Occurred()) SWIG_fail;
17240 }
17241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17242 return resultobj;
17243 fail:
17244 return NULL;
17245 }
17246
17247
17248 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17249 PyObject *obj;
17250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17251 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17252 return SWIG_Py_Void();
17253 }
17254
17255 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17256 return SWIG_Python_InitShadowInstance(args);
17257 }
17258
17259 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17260 PyObject *resultobj = 0;
17261 wxANIHandler *result = 0 ;
17262
17263 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17264 {
17265 PyThreadState* __tstate = wxPyBeginAllowThreads();
17266 result = (wxANIHandler *)new wxANIHandler();
17267 wxPyEndAllowThreads(__tstate);
17268 if (PyErr_Occurred()) SWIG_fail;
17269 }
17270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17278 PyObject *obj;
17279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17280 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17281 return SWIG_Py_Void();
17282 }
17283
17284 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17285 return SWIG_Python_InitShadowInstance(args);
17286 }
17287
17288 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17289 PyObject *resultobj = 0;
17290 wxPNGHandler *result = 0 ;
17291
17292 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17293 {
17294 PyThreadState* __tstate = wxPyBeginAllowThreads();
17295 result = (wxPNGHandler *)new wxPNGHandler();
17296 wxPyEndAllowThreads(__tstate);
17297 if (PyErr_Occurred()) SWIG_fail;
17298 }
17299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17300 return resultobj;
17301 fail:
17302 return NULL;
17303 }
17304
17305
17306 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17307 PyObject *obj;
17308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17309 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17310 return SWIG_Py_Void();
17311 }
17312
17313 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17314 return SWIG_Python_InitShadowInstance(args);
17315 }
17316
17317 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17318 PyObject *resultobj = 0;
17319 wxGIFHandler *result = 0 ;
17320
17321 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17322 {
17323 PyThreadState* __tstate = wxPyBeginAllowThreads();
17324 result = (wxGIFHandler *)new wxGIFHandler();
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 PyObject *obj;
17337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17338 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17339 return SWIG_Py_Void();
17340 }
17341
17342 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17343 return SWIG_Python_InitShadowInstance(args);
17344 }
17345
17346 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17347 PyObject *resultobj = 0;
17348 wxPCXHandler *result = 0 ;
17349
17350 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (wxPCXHandler *)new wxPCXHandler();
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17358 return resultobj;
17359 fail:
17360 return NULL;
17361 }
17362
17363
17364 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17365 PyObject *obj;
17366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17367 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17368 return SWIG_Py_Void();
17369 }
17370
17371 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17372 return SWIG_Python_InitShadowInstance(args);
17373 }
17374
17375 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17376 PyObject *resultobj = 0;
17377 wxJPEGHandler *result = 0 ;
17378
17379 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17380 {
17381 PyThreadState* __tstate = wxPyBeginAllowThreads();
17382 result = (wxJPEGHandler *)new wxJPEGHandler();
17383 wxPyEndAllowThreads(__tstate);
17384 if (PyErr_Occurred()) SWIG_fail;
17385 }
17386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17387 return resultobj;
17388 fail:
17389 return NULL;
17390 }
17391
17392
17393 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17394 PyObject *obj;
17395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17396 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17397 return SWIG_Py_Void();
17398 }
17399
17400 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17401 return SWIG_Python_InitShadowInstance(args);
17402 }
17403
17404 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17405 PyObject *resultobj = 0;
17406 wxPNMHandler *result = 0 ;
17407
17408 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17409 {
17410 PyThreadState* __tstate = wxPyBeginAllowThreads();
17411 result = (wxPNMHandler *)new wxPNMHandler();
17412 wxPyEndAllowThreads(__tstate);
17413 if (PyErr_Occurred()) SWIG_fail;
17414 }
17415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17416 return resultobj;
17417 fail:
17418 return NULL;
17419 }
17420
17421
17422 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17423 PyObject *obj;
17424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17425 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17426 return SWIG_Py_Void();
17427 }
17428
17429 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17430 return SWIG_Python_InitShadowInstance(args);
17431 }
17432
17433 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17434 PyObject *resultobj = 0;
17435 wxXPMHandler *result = 0 ;
17436
17437 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17438 {
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (wxXPMHandler *)new wxXPMHandler();
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17445 return resultobj;
17446 fail:
17447 return NULL;
17448 }
17449
17450
17451 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17452 PyObject *obj;
17453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17454 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17455 return SWIG_Py_Void();
17456 }
17457
17458 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17459 return SWIG_Python_InitShadowInstance(args);
17460 }
17461
17462 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 PyObject *resultobj = 0;
17464 wxTIFFHandler *result = 0 ;
17465
17466 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17467 {
17468 PyThreadState* __tstate = wxPyBeginAllowThreads();
17469 result = (wxTIFFHandler *)new wxTIFFHandler();
17470 wxPyEndAllowThreads(__tstate);
17471 if (PyErr_Occurred()) SWIG_fail;
17472 }
17473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17474 return resultobj;
17475 fail:
17476 return NULL;
17477 }
17478
17479
17480 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17481 PyObject *obj;
17482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17483 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17484 return SWIG_Py_Void();
17485 }
17486
17487 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17488 return SWIG_Python_InitShadowInstance(args);
17489 }
17490
17491 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17492 PyObject *resultobj = 0;
17493 wxImage *arg1 = 0 ;
17494 wxImage *arg2 = 0 ;
17495 int arg3 = (int) 236 ;
17496 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17497 bool result;
17498 void *argp1 = 0 ;
17499 int res1 = 0 ;
17500 void *argp2 = 0 ;
17501 int res2 = 0 ;
17502 int val3 ;
17503 int ecode3 = 0 ;
17504 int val4 ;
17505 int ecode4 = 0 ;
17506 PyObject * obj0 = 0 ;
17507 PyObject * obj1 = 0 ;
17508 PyObject * obj2 = 0 ;
17509 PyObject * obj3 = 0 ;
17510 char * kwnames[] = {
17511 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17512 };
17513
17514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17515 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17516 if (!SWIG_IsOK(res1)) {
17517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17518 }
17519 if (!argp1) {
17520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17521 }
17522 arg1 = reinterpret_cast< wxImage * >(argp1);
17523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17524 if (!SWIG_IsOK(res2)) {
17525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17526 }
17527 if (!argp2) {
17528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17529 }
17530 arg2 = reinterpret_cast< wxImage * >(argp2);
17531 if (obj2) {
17532 ecode3 = SWIG_AsVal_int(obj2, &val3);
17533 if (!SWIG_IsOK(ecode3)) {
17534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17535 }
17536 arg3 = static_cast< int >(val3);
17537 }
17538 if (obj3) {
17539 ecode4 = SWIG_AsVal_int(obj3, &val4);
17540 if (!SWIG_IsOK(ecode4)) {
17541 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17542 }
17543 arg4 = static_cast< int >(val4);
17544 }
17545 {
17546 PyThreadState* __tstate = wxPyBeginAllowThreads();
17547 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17548 wxPyEndAllowThreads(__tstate);
17549 if (PyErr_Occurred()) SWIG_fail;
17550 }
17551 {
17552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17553 }
17554 return resultobj;
17555 fail:
17556 return NULL;
17557 }
17558
17559
17560 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17561 PyObject *obj;
17562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17563 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17564 return SWIG_Py_Void();
17565 }
17566
17567 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17568 PyObject *resultobj = 0;
17569 wxEvtHandler *result = 0 ;
17570
17571 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17572 {
17573 PyThreadState* __tstate = wxPyBeginAllowThreads();
17574 result = (wxEvtHandler *)new wxEvtHandler();
17575 wxPyEndAllowThreads(__tstate);
17576 if (PyErr_Occurred()) SWIG_fail;
17577 }
17578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17579 return resultobj;
17580 fail:
17581 return NULL;
17582 }
17583
17584
17585 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17586 PyObject *resultobj = 0;
17587 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17588 wxEvtHandler *result = 0 ;
17589 void *argp1 = 0 ;
17590 int res1 = 0 ;
17591 PyObject *swig_obj[1] ;
17592
17593 if (!args) SWIG_fail;
17594 swig_obj[0] = args;
17595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17596 if (!SWIG_IsOK(res1)) {
17597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17598 }
17599 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17600 {
17601 PyThreadState* __tstate = wxPyBeginAllowThreads();
17602 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17603 wxPyEndAllowThreads(__tstate);
17604 if (PyErr_Occurred()) SWIG_fail;
17605 }
17606 {
17607 resultobj = wxPyMake_wxObject(result, 0);
17608 }
17609 return resultobj;
17610 fail:
17611 return NULL;
17612 }
17613
17614
17615 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17616 PyObject *resultobj = 0;
17617 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17618 wxEvtHandler *result = 0 ;
17619 void *argp1 = 0 ;
17620 int res1 = 0 ;
17621 PyObject *swig_obj[1] ;
17622
17623 if (!args) SWIG_fail;
17624 swig_obj[0] = args;
17625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17626 if (!SWIG_IsOK(res1)) {
17627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17628 }
17629 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17630 {
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17633 wxPyEndAllowThreads(__tstate);
17634 if (PyErr_Occurred()) SWIG_fail;
17635 }
17636 {
17637 resultobj = wxPyMake_wxObject(result, 0);
17638 }
17639 return resultobj;
17640 fail:
17641 return NULL;
17642 }
17643
17644
17645 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17646 PyObject *resultobj = 0;
17647 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17648 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17649 void *argp1 = 0 ;
17650 int res1 = 0 ;
17651 void *argp2 = 0 ;
17652 int res2 = 0 ;
17653 PyObject * obj0 = 0 ;
17654 PyObject * obj1 = 0 ;
17655 char * kwnames[] = {
17656 (char *) "self",(char *) "handler", NULL
17657 };
17658
17659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17661 if (!SWIG_IsOK(res1)) {
17662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17663 }
17664 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17665 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17666 if (!SWIG_IsOK(res2)) {
17667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17668 }
17669 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17670 {
17671 PyThreadState* __tstate = wxPyBeginAllowThreads();
17672 (arg1)->SetNextHandler(arg2);
17673 wxPyEndAllowThreads(__tstate);
17674 if (PyErr_Occurred()) SWIG_fail;
17675 }
17676 resultobj = SWIG_Py_Void();
17677 return resultobj;
17678 fail:
17679 return NULL;
17680 }
17681
17682
17683 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17684 PyObject *resultobj = 0;
17685 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17686 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17687 void *argp1 = 0 ;
17688 int res1 = 0 ;
17689 void *argp2 = 0 ;
17690 int res2 = 0 ;
17691 PyObject * obj0 = 0 ;
17692 PyObject * obj1 = 0 ;
17693 char * kwnames[] = {
17694 (char *) "self",(char *) "handler", NULL
17695 };
17696
17697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17699 if (!SWIG_IsOK(res1)) {
17700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17701 }
17702 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17703 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17704 if (!SWIG_IsOK(res2)) {
17705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17706 }
17707 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17708 {
17709 PyThreadState* __tstate = wxPyBeginAllowThreads();
17710 (arg1)->SetPreviousHandler(arg2);
17711 wxPyEndAllowThreads(__tstate);
17712 if (PyErr_Occurred()) SWIG_fail;
17713 }
17714 resultobj = SWIG_Py_Void();
17715 return resultobj;
17716 fail:
17717 return NULL;
17718 }
17719
17720
17721 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17722 PyObject *resultobj = 0;
17723 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17724 bool result;
17725 void *argp1 = 0 ;
17726 int res1 = 0 ;
17727 PyObject *swig_obj[1] ;
17728
17729 if (!args) SWIG_fail;
17730 swig_obj[0] = args;
17731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17732 if (!SWIG_IsOK(res1)) {
17733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17734 }
17735 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17736 {
17737 PyThreadState* __tstate = wxPyBeginAllowThreads();
17738 result = (bool)(arg1)->GetEvtHandlerEnabled();
17739 wxPyEndAllowThreads(__tstate);
17740 if (PyErr_Occurred()) SWIG_fail;
17741 }
17742 {
17743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17744 }
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj = 0;
17753 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17754 bool arg2 ;
17755 void *argp1 = 0 ;
17756 int res1 = 0 ;
17757 bool val2 ;
17758 int ecode2 = 0 ;
17759 PyObject * obj0 = 0 ;
17760 PyObject * obj1 = 0 ;
17761 char * kwnames[] = {
17762 (char *) "self",(char *) "enabled", NULL
17763 };
17764
17765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17767 if (!SWIG_IsOK(res1)) {
17768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17769 }
17770 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17772 if (!SWIG_IsOK(ecode2)) {
17773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17774 }
17775 arg2 = static_cast< bool >(val2);
17776 {
17777 PyThreadState* __tstate = wxPyBeginAllowThreads();
17778 (arg1)->SetEvtHandlerEnabled(arg2);
17779 wxPyEndAllowThreads(__tstate);
17780 if (PyErr_Occurred()) SWIG_fail;
17781 }
17782 resultobj = SWIG_Py_Void();
17783 return resultobj;
17784 fail:
17785 return NULL;
17786 }
17787
17788
17789 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17790 PyObject *resultobj = 0;
17791 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17792 wxEvent *arg2 = 0 ;
17793 bool result;
17794 void *argp1 = 0 ;
17795 int res1 = 0 ;
17796 void *argp2 = 0 ;
17797 int res2 = 0 ;
17798 PyObject * obj0 = 0 ;
17799 PyObject * obj1 = 0 ;
17800 char * kwnames[] = {
17801 (char *) "self",(char *) "event", NULL
17802 };
17803
17804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17806 if (!SWIG_IsOK(res1)) {
17807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17808 }
17809 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17810 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17811 if (!SWIG_IsOK(res2)) {
17812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17813 }
17814 if (!argp2) {
17815 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17816 }
17817 arg2 = reinterpret_cast< wxEvent * >(argp2);
17818 {
17819 PyThreadState* __tstate = wxPyBeginAllowThreads();
17820 result = (bool)(arg1)->ProcessEvent(*arg2);
17821 wxPyEndAllowThreads(__tstate);
17822 if (PyErr_Occurred()) SWIG_fail;
17823 }
17824 {
17825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17826 }
17827 return resultobj;
17828 fail:
17829 return NULL;
17830 }
17831
17832
17833 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17834 PyObject *resultobj = 0;
17835 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17836 wxEvent *arg2 = 0 ;
17837 void *argp1 = 0 ;
17838 int res1 = 0 ;
17839 void *argp2 = 0 ;
17840 int res2 = 0 ;
17841 PyObject * obj0 = 0 ;
17842 PyObject * obj1 = 0 ;
17843 char * kwnames[] = {
17844 (char *) "self",(char *) "event", NULL
17845 };
17846
17847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17849 if (!SWIG_IsOK(res1)) {
17850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17851 }
17852 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17853 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17854 if (!SWIG_IsOK(res2)) {
17855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17856 }
17857 if (!argp2) {
17858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17859 }
17860 arg2 = reinterpret_cast< wxEvent * >(argp2);
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 (arg1)->AddPendingEvent(*arg2);
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 resultobj = SWIG_Py_Void();
17868 return resultobj;
17869 fail:
17870 return NULL;
17871 }
17872
17873
17874 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17875 PyObject *resultobj = 0;
17876 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17877 void *argp1 = 0 ;
17878 int res1 = 0 ;
17879 PyObject *swig_obj[1] ;
17880
17881 if (!args) SWIG_fail;
17882 swig_obj[0] = args;
17883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17884 if (!SWIG_IsOK(res1)) {
17885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17886 }
17887 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17888 {
17889 PyThreadState* __tstate = wxPyBeginAllowThreads();
17890 (arg1)->ProcessPendingEvents();
17891 wxPyEndAllowThreads(__tstate);
17892 if (PyErr_Occurred()) SWIG_fail;
17893 }
17894 resultobj = SWIG_Py_Void();
17895 return resultobj;
17896 fail:
17897 return NULL;
17898 }
17899
17900
17901 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17902 PyObject *resultobj = 0;
17903 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17904 int arg2 ;
17905 int arg3 ;
17906 int arg4 ;
17907 PyObject *arg5 = (PyObject *) 0 ;
17908 void *argp1 = 0 ;
17909 int res1 = 0 ;
17910 int val2 ;
17911 int ecode2 = 0 ;
17912 int val3 ;
17913 int ecode3 = 0 ;
17914 int val4 ;
17915 int ecode4 = 0 ;
17916 PyObject * obj0 = 0 ;
17917 PyObject * obj1 = 0 ;
17918 PyObject * obj2 = 0 ;
17919 PyObject * obj3 = 0 ;
17920 PyObject * obj4 = 0 ;
17921 char * kwnames[] = {
17922 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17923 };
17924
17925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17927 if (!SWIG_IsOK(res1)) {
17928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17929 }
17930 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17931 ecode2 = SWIG_AsVal_int(obj1, &val2);
17932 if (!SWIG_IsOK(ecode2)) {
17933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17934 }
17935 arg2 = static_cast< int >(val2);
17936 ecode3 = SWIG_AsVal_int(obj2, &val3);
17937 if (!SWIG_IsOK(ecode3)) {
17938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17939 }
17940 arg3 = static_cast< int >(val3);
17941 ecode4 = SWIG_AsVal_int(obj3, &val4);
17942 if (!SWIG_IsOK(ecode4)) {
17943 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17944 }
17945 arg4 = static_cast< int >(val4);
17946 arg5 = obj4;
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17950 wxPyEndAllowThreads(__tstate);
17951 if (PyErr_Occurred()) SWIG_fail;
17952 }
17953 resultobj = SWIG_Py_Void();
17954 return resultobj;
17955 fail:
17956 return NULL;
17957 }
17958
17959
17960 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17961 PyObject *resultobj = 0;
17962 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17963 int arg2 ;
17964 int arg3 = (int) -1 ;
17965 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17966 bool result;
17967 void *argp1 = 0 ;
17968 int res1 = 0 ;
17969 int val2 ;
17970 int ecode2 = 0 ;
17971 int val3 ;
17972 int ecode3 = 0 ;
17973 int val4 ;
17974 int ecode4 = 0 ;
17975 PyObject * obj0 = 0 ;
17976 PyObject * obj1 = 0 ;
17977 PyObject * obj2 = 0 ;
17978 PyObject * obj3 = 0 ;
17979 char * kwnames[] = {
17980 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17981 };
17982
17983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17985 if (!SWIG_IsOK(res1)) {
17986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17987 }
17988 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17989 ecode2 = SWIG_AsVal_int(obj1, &val2);
17990 if (!SWIG_IsOK(ecode2)) {
17991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17992 }
17993 arg2 = static_cast< int >(val2);
17994 if (obj2) {
17995 ecode3 = SWIG_AsVal_int(obj2, &val3);
17996 if (!SWIG_IsOK(ecode3)) {
17997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17998 }
17999 arg3 = static_cast< int >(val3);
18000 }
18001 if (obj3) {
18002 ecode4 = SWIG_AsVal_int(obj3, &val4);
18003 if (!SWIG_IsOK(ecode4)) {
18004 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18005 }
18006 arg4 = static_cast< wxEventType >(val4);
18007 }
18008 {
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18011 wxPyEndAllowThreads(__tstate);
18012 if (PyErr_Occurred()) SWIG_fail;
18013 }
18014 {
18015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18016 }
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj = 0;
18025 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18026 PyObject *arg2 = (PyObject *) 0 ;
18027 bool arg3 = (bool) true ;
18028 void *argp1 = 0 ;
18029 int res1 = 0 ;
18030 bool val3 ;
18031 int ecode3 = 0 ;
18032 PyObject * obj0 = 0 ;
18033 PyObject * obj1 = 0 ;
18034 PyObject * obj2 = 0 ;
18035 char * kwnames[] = {
18036 (char *) "self",(char *) "_self",(char *) "incref", NULL
18037 };
18038
18039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18041 if (!SWIG_IsOK(res1)) {
18042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18043 }
18044 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18045 arg2 = obj1;
18046 if (obj2) {
18047 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18048 if (!SWIG_IsOK(ecode3)) {
18049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18050 }
18051 arg3 = static_cast< bool >(val3);
18052 }
18053 {
18054 PyThreadState* __tstate = wxPyBeginAllowThreads();
18055 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18056 wxPyEndAllowThreads(__tstate);
18057 if (PyErr_Occurred()) SWIG_fail;
18058 }
18059 resultobj = SWIG_Py_Void();
18060 return resultobj;
18061 fail:
18062 return NULL;
18063 }
18064
18065
18066 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18067 PyObject *obj;
18068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18069 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18070 return SWIG_Py_Void();
18071 }
18072
18073 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18074 return SWIG_Python_InitShadowInstance(args);
18075 }
18076
18077 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18078 PyObject *resultobj = 0;
18079 wxEventType result;
18080
18081 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = (wxEventType)wxNewEventType();
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 resultobj = SWIG_From_int(static_cast< int >(result));
18089 return resultobj;
18090 fail:
18091 return NULL;
18092 }
18093
18094
18095 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18096 PyObject *resultobj = 0;
18097 wxEvent *arg1 = (wxEvent *) 0 ;
18098 void *argp1 = 0 ;
18099 int res1 = 0 ;
18100 PyObject *swig_obj[1] ;
18101
18102 if (!args) SWIG_fail;
18103 swig_obj[0] = args;
18104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18105 if (!SWIG_IsOK(res1)) {
18106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18107 }
18108 arg1 = reinterpret_cast< wxEvent * >(argp1);
18109 {
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 delete arg1;
18112
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 resultobj = SWIG_Py_Void();
18117 return resultobj;
18118 fail:
18119 return NULL;
18120 }
18121
18122
18123 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18124 PyObject *resultobj = 0;
18125 wxEvent *arg1 = (wxEvent *) 0 ;
18126 wxEventType arg2 ;
18127 void *argp1 = 0 ;
18128 int res1 = 0 ;
18129 int val2 ;
18130 int ecode2 = 0 ;
18131 PyObject * obj0 = 0 ;
18132 PyObject * obj1 = 0 ;
18133 char * kwnames[] = {
18134 (char *) "self",(char *) "typ", NULL
18135 };
18136
18137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18139 if (!SWIG_IsOK(res1)) {
18140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18141 }
18142 arg1 = reinterpret_cast< wxEvent * >(argp1);
18143 ecode2 = SWIG_AsVal_int(obj1, &val2);
18144 if (!SWIG_IsOK(ecode2)) {
18145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18146 }
18147 arg2 = static_cast< wxEventType >(val2);
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 (arg1)->SetEventType(arg2);
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 resultobj = SWIG_Py_Void();
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18162 PyObject *resultobj = 0;
18163 wxEvent *arg1 = (wxEvent *) 0 ;
18164 wxEventType result;
18165 void *argp1 = 0 ;
18166 int res1 = 0 ;
18167 PyObject *swig_obj[1] ;
18168
18169 if (!args) SWIG_fail;
18170 swig_obj[0] = args;
18171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18172 if (!SWIG_IsOK(res1)) {
18173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18174 }
18175 arg1 = reinterpret_cast< wxEvent * >(argp1);
18176 {
18177 PyThreadState* __tstate = wxPyBeginAllowThreads();
18178 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18179 wxPyEndAllowThreads(__tstate);
18180 if (PyErr_Occurred()) SWIG_fail;
18181 }
18182 resultobj = SWIG_From_int(static_cast< int >(result));
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18190 PyObject *resultobj = 0;
18191 wxEvent *arg1 = (wxEvent *) 0 ;
18192 wxObject *result = 0 ;
18193 void *argp1 = 0 ;
18194 int res1 = 0 ;
18195 PyObject *swig_obj[1] ;
18196
18197 if (!args) SWIG_fail;
18198 swig_obj[0] = args;
18199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18200 if (!SWIG_IsOK(res1)) {
18201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18202 }
18203 arg1 = reinterpret_cast< wxEvent * >(argp1);
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 {
18211 resultobj = wxPyMake_wxObject(result, (bool)0);
18212 }
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18220 PyObject *resultobj = 0;
18221 wxEvent *arg1 = (wxEvent *) 0 ;
18222 wxObject *arg2 = (wxObject *) 0 ;
18223 void *argp1 = 0 ;
18224 int res1 = 0 ;
18225 void *argp2 = 0 ;
18226 int res2 = 0 ;
18227 PyObject * obj0 = 0 ;
18228 PyObject * obj1 = 0 ;
18229 char * kwnames[] = {
18230 (char *) "self",(char *) "obj", NULL
18231 };
18232
18233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18235 if (!SWIG_IsOK(res1)) {
18236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18237 }
18238 arg1 = reinterpret_cast< wxEvent * >(argp1);
18239 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18240 if (!SWIG_IsOK(res2)) {
18241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18242 }
18243 arg2 = reinterpret_cast< wxObject * >(argp2);
18244 {
18245 PyThreadState* __tstate = wxPyBeginAllowThreads();
18246 (arg1)->SetEventObject(arg2);
18247 wxPyEndAllowThreads(__tstate);
18248 if (PyErr_Occurred()) SWIG_fail;
18249 }
18250 resultobj = SWIG_Py_Void();
18251 return resultobj;
18252 fail:
18253 return NULL;
18254 }
18255
18256
18257 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18258 PyObject *resultobj = 0;
18259 wxEvent *arg1 = (wxEvent *) 0 ;
18260 long result;
18261 void *argp1 = 0 ;
18262 int res1 = 0 ;
18263 PyObject *swig_obj[1] ;
18264
18265 if (!args) SWIG_fail;
18266 swig_obj[0] = args;
18267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18268 if (!SWIG_IsOK(res1)) {
18269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18270 }
18271 arg1 = reinterpret_cast< wxEvent * >(argp1);
18272 {
18273 PyThreadState* __tstate = wxPyBeginAllowThreads();
18274 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18275 wxPyEndAllowThreads(__tstate);
18276 if (PyErr_Occurred()) SWIG_fail;
18277 }
18278 resultobj = SWIG_From_long(static_cast< long >(result));
18279 return resultobj;
18280 fail:
18281 return NULL;
18282 }
18283
18284
18285 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18286 PyObject *resultobj = 0;
18287 wxEvent *arg1 = (wxEvent *) 0 ;
18288 long arg2 = (long) 0 ;
18289 void *argp1 = 0 ;
18290 int res1 = 0 ;
18291 long val2 ;
18292 int ecode2 = 0 ;
18293 PyObject * obj0 = 0 ;
18294 PyObject * obj1 = 0 ;
18295 char * kwnames[] = {
18296 (char *) "self",(char *) "ts", NULL
18297 };
18298
18299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18301 if (!SWIG_IsOK(res1)) {
18302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18303 }
18304 arg1 = reinterpret_cast< wxEvent * >(argp1);
18305 if (obj1) {
18306 ecode2 = SWIG_AsVal_long(obj1, &val2);
18307 if (!SWIG_IsOK(ecode2)) {
18308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18309 }
18310 arg2 = static_cast< long >(val2);
18311 }
18312 {
18313 PyThreadState* __tstate = wxPyBeginAllowThreads();
18314 (arg1)->SetTimestamp(arg2);
18315 wxPyEndAllowThreads(__tstate);
18316 if (PyErr_Occurred()) SWIG_fail;
18317 }
18318 resultobj = SWIG_Py_Void();
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18326 PyObject *resultobj = 0;
18327 wxEvent *arg1 = (wxEvent *) 0 ;
18328 int result;
18329 void *argp1 = 0 ;
18330 int res1 = 0 ;
18331 PyObject *swig_obj[1] ;
18332
18333 if (!args) SWIG_fail;
18334 swig_obj[0] = args;
18335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18336 if (!SWIG_IsOK(res1)) {
18337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18338 }
18339 arg1 = reinterpret_cast< wxEvent * >(argp1);
18340 {
18341 PyThreadState* __tstate = wxPyBeginAllowThreads();
18342 result = (int)((wxEvent const *)arg1)->GetId();
18343 wxPyEndAllowThreads(__tstate);
18344 if (PyErr_Occurred()) SWIG_fail;
18345 }
18346 resultobj = SWIG_From_int(static_cast< int >(result));
18347 return resultobj;
18348 fail:
18349 return NULL;
18350 }
18351
18352
18353 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18354 PyObject *resultobj = 0;
18355 wxEvent *arg1 = (wxEvent *) 0 ;
18356 int arg2 ;
18357 void *argp1 = 0 ;
18358 int res1 = 0 ;
18359 int val2 ;
18360 int ecode2 = 0 ;
18361 PyObject * obj0 = 0 ;
18362 PyObject * obj1 = 0 ;
18363 char * kwnames[] = {
18364 (char *) "self",(char *) "Id", NULL
18365 };
18366
18367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18369 if (!SWIG_IsOK(res1)) {
18370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18371 }
18372 arg1 = reinterpret_cast< wxEvent * >(argp1);
18373 ecode2 = SWIG_AsVal_int(obj1, &val2);
18374 if (!SWIG_IsOK(ecode2)) {
18375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18376 }
18377 arg2 = static_cast< int >(val2);
18378 {
18379 PyThreadState* __tstate = wxPyBeginAllowThreads();
18380 (arg1)->SetId(arg2);
18381 wxPyEndAllowThreads(__tstate);
18382 if (PyErr_Occurred()) SWIG_fail;
18383 }
18384 resultobj = SWIG_Py_Void();
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18392 PyObject *resultobj = 0;
18393 wxEvent *arg1 = (wxEvent *) 0 ;
18394 bool result;
18395 void *argp1 = 0 ;
18396 int res1 = 0 ;
18397 PyObject *swig_obj[1] ;
18398
18399 if (!args) SWIG_fail;
18400 swig_obj[0] = args;
18401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18402 if (!SWIG_IsOK(res1)) {
18403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18404 }
18405 arg1 = reinterpret_cast< wxEvent * >(argp1);
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18409 wxPyEndAllowThreads(__tstate);
18410 if (PyErr_Occurred()) SWIG_fail;
18411 }
18412 {
18413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18414 }
18415 return resultobj;
18416 fail:
18417 return NULL;
18418 }
18419
18420
18421 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18422 PyObject *resultobj = 0;
18423 wxEvent *arg1 = (wxEvent *) 0 ;
18424 bool arg2 = (bool) true ;
18425 void *argp1 = 0 ;
18426 int res1 = 0 ;
18427 bool val2 ;
18428 int ecode2 = 0 ;
18429 PyObject * obj0 = 0 ;
18430 PyObject * obj1 = 0 ;
18431 char * kwnames[] = {
18432 (char *) "self",(char *) "skip", NULL
18433 };
18434
18435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18437 if (!SWIG_IsOK(res1)) {
18438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18439 }
18440 arg1 = reinterpret_cast< wxEvent * >(argp1);
18441 if (obj1) {
18442 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18443 if (!SWIG_IsOK(ecode2)) {
18444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18445 }
18446 arg2 = static_cast< bool >(val2);
18447 }
18448 {
18449 PyThreadState* __tstate = wxPyBeginAllowThreads();
18450 (arg1)->Skip(arg2);
18451 wxPyEndAllowThreads(__tstate);
18452 if (PyErr_Occurred()) SWIG_fail;
18453 }
18454 resultobj = SWIG_Py_Void();
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18462 PyObject *resultobj = 0;
18463 wxEvent *arg1 = (wxEvent *) 0 ;
18464 bool result;
18465 void *argp1 = 0 ;
18466 int res1 = 0 ;
18467 PyObject *swig_obj[1] ;
18468
18469 if (!args) SWIG_fail;
18470 swig_obj[0] = args;
18471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18472 if (!SWIG_IsOK(res1)) {
18473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18474 }
18475 arg1 = reinterpret_cast< wxEvent * >(argp1);
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18479 wxPyEndAllowThreads(__tstate);
18480 if (PyErr_Occurred()) SWIG_fail;
18481 }
18482 {
18483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18484 }
18485 return resultobj;
18486 fail:
18487 return NULL;
18488 }
18489
18490
18491 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18492 PyObject *resultobj = 0;
18493 wxEvent *arg1 = (wxEvent *) 0 ;
18494 bool result;
18495 void *argp1 = 0 ;
18496 int res1 = 0 ;
18497 PyObject *swig_obj[1] ;
18498
18499 if (!args) SWIG_fail;
18500 swig_obj[0] = args;
18501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18502 if (!SWIG_IsOK(res1)) {
18503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18504 }
18505 arg1 = reinterpret_cast< wxEvent * >(argp1);
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18509 wxPyEndAllowThreads(__tstate);
18510 if (PyErr_Occurred()) SWIG_fail;
18511 }
18512 {
18513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18514 }
18515 return resultobj;
18516 fail:
18517 return NULL;
18518 }
18519
18520
18521 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18522 PyObject *resultobj = 0;
18523 wxEvent *arg1 = (wxEvent *) 0 ;
18524 int result;
18525 void *argp1 = 0 ;
18526 int res1 = 0 ;
18527 PyObject *swig_obj[1] ;
18528
18529 if (!args) SWIG_fail;
18530 swig_obj[0] = args;
18531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18532 if (!SWIG_IsOK(res1)) {
18533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18534 }
18535 arg1 = reinterpret_cast< wxEvent * >(argp1);
18536 {
18537 PyThreadState* __tstate = wxPyBeginAllowThreads();
18538 result = (int)(arg1)->StopPropagation();
18539 wxPyEndAllowThreads(__tstate);
18540 if (PyErr_Occurred()) SWIG_fail;
18541 }
18542 resultobj = SWIG_From_int(static_cast< int >(result));
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18550 PyObject *resultobj = 0;
18551 wxEvent *arg1 = (wxEvent *) 0 ;
18552 int arg2 ;
18553 void *argp1 = 0 ;
18554 int res1 = 0 ;
18555 int val2 ;
18556 int ecode2 = 0 ;
18557 PyObject * obj0 = 0 ;
18558 PyObject * obj1 = 0 ;
18559 char * kwnames[] = {
18560 (char *) "self",(char *) "propagationLevel", NULL
18561 };
18562
18563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18565 if (!SWIG_IsOK(res1)) {
18566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18567 }
18568 arg1 = reinterpret_cast< wxEvent * >(argp1);
18569 ecode2 = SWIG_AsVal_int(obj1, &val2);
18570 if (!SWIG_IsOK(ecode2)) {
18571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18572 }
18573 arg2 = static_cast< int >(val2);
18574 {
18575 PyThreadState* __tstate = wxPyBeginAllowThreads();
18576 (arg1)->ResumePropagation(arg2);
18577 wxPyEndAllowThreads(__tstate);
18578 if (PyErr_Occurred()) SWIG_fail;
18579 }
18580 resultobj = SWIG_Py_Void();
18581 return resultobj;
18582 fail:
18583 return NULL;
18584 }
18585
18586
18587 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18588 PyObject *resultobj = 0;
18589 wxEvent *arg1 = (wxEvent *) 0 ;
18590 wxEvent *result = 0 ;
18591 void *argp1 = 0 ;
18592 int res1 = 0 ;
18593 PyObject *swig_obj[1] ;
18594
18595 if (!args) SWIG_fail;
18596 swig_obj[0] = args;
18597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18598 if (!SWIG_IsOK(res1)) {
18599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18600 }
18601 arg1 = reinterpret_cast< wxEvent * >(argp1);
18602 {
18603 PyThreadState* __tstate = wxPyBeginAllowThreads();
18604 result = (wxEvent *)(arg1)->Clone();
18605 wxPyEndAllowThreads(__tstate);
18606 if (PyErr_Occurred()) SWIG_fail;
18607 }
18608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18609 return resultobj;
18610 fail:
18611 return NULL;
18612 }
18613
18614
18615 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18616 PyObject *obj;
18617 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18618 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18619 return SWIG_Py_Void();
18620 }
18621
18622 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18623 PyObject *resultobj = 0;
18624 wxEvent *arg1 = 0 ;
18625 wxPropagationDisabler *result = 0 ;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 PyObject * obj0 = 0 ;
18629 char * kwnames[] = {
18630 (char *) "event", NULL
18631 };
18632
18633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18634 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18635 if (!SWIG_IsOK(res1)) {
18636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18637 }
18638 if (!argp1) {
18639 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18640 }
18641 arg1 = reinterpret_cast< wxEvent * >(argp1);
18642 {
18643 PyThreadState* __tstate = wxPyBeginAllowThreads();
18644 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18645 wxPyEndAllowThreads(__tstate);
18646 if (PyErr_Occurred()) SWIG_fail;
18647 }
18648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18649 return resultobj;
18650 fail:
18651 return NULL;
18652 }
18653
18654
18655 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18656 PyObject *resultobj = 0;
18657 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18658 void *argp1 = 0 ;
18659 int res1 = 0 ;
18660 PyObject *swig_obj[1] ;
18661
18662 if (!args) SWIG_fail;
18663 swig_obj[0] = args;
18664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18665 if (!SWIG_IsOK(res1)) {
18666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18667 }
18668 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18669 {
18670 PyThreadState* __tstate = wxPyBeginAllowThreads();
18671 delete arg1;
18672
18673 wxPyEndAllowThreads(__tstate);
18674 if (PyErr_Occurred()) SWIG_fail;
18675 }
18676 resultobj = SWIG_Py_Void();
18677 return resultobj;
18678 fail:
18679 return NULL;
18680 }
18681
18682
18683 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18684 PyObject *obj;
18685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18686 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18687 return SWIG_Py_Void();
18688 }
18689
18690 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18691 return SWIG_Python_InitShadowInstance(args);
18692 }
18693
18694 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18695 PyObject *resultobj = 0;
18696 wxEvent *arg1 = 0 ;
18697 wxPropagateOnce *result = 0 ;
18698 void *argp1 = 0 ;
18699 int res1 = 0 ;
18700 PyObject * obj0 = 0 ;
18701 char * kwnames[] = {
18702 (char *) "event", NULL
18703 };
18704
18705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18706 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18707 if (!SWIG_IsOK(res1)) {
18708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18709 }
18710 if (!argp1) {
18711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18712 }
18713 arg1 = reinterpret_cast< wxEvent * >(argp1);
18714 {
18715 PyThreadState* __tstate = wxPyBeginAllowThreads();
18716 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18717 wxPyEndAllowThreads(__tstate);
18718 if (PyErr_Occurred()) SWIG_fail;
18719 }
18720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18721 return resultobj;
18722 fail:
18723 return NULL;
18724 }
18725
18726
18727 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18728 PyObject *resultobj = 0;
18729 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18730 void *argp1 = 0 ;
18731 int res1 = 0 ;
18732 PyObject *swig_obj[1] ;
18733
18734 if (!args) SWIG_fail;
18735 swig_obj[0] = args;
18736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18737 if (!SWIG_IsOK(res1)) {
18738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18739 }
18740 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18741 {
18742 PyThreadState* __tstate = wxPyBeginAllowThreads();
18743 delete arg1;
18744
18745 wxPyEndAllowThreads(__tstate);
18746 if (PyErr_Occurred()) SWIG_fail;
18747 }
18748 resultobj = SWIG_Py_Void();
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18756 PyObject *obj;
18757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18758 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18759 return SWIG_Py_Void();
18760 }
18761
18762 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18763 return SWIG_Python_InitShadowInstance(args);
18764 }
18765
18766 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18767 PyObject *resultobj = 0;
18768 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18769 int arg2 = (int) 0 ;
18770 wxCommandEvent *result = 0 ;
18771 int val1 ;
18772 int ecode1 = 0 ;
18773 int val2 ;
18774 int ecode2 = 0 ;
18775 PyObject * obj0 = 0 ;
18776 PyObject * obj1 = 0 ;
18777 char * kwnames[] = {
18778 (char *) "commandType",(char *) "winid", NULL
18779 };
18780
18781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18782 if (obj0) {
18783 ecode1 = SWIG_AsVal_int(obj0, &val1);
18784 if (!SWIG_IsOK(ecode1)) {
18785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18786 }
18787 arg1 = static_cast< wxEventType >(val1);
18788 }
18789 if (obj1) {
18790 ecode2 = SWIG_AsVal_int(obj1, &val2);
18791 if (!SWIG_IsOK(ecode2)) {
18792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18793 }
18794 arg2 = static_cast< int >(val2);
18795 }
18796 {
18797 PyThreadState* __tstate = wxPyBeginAllowThreads();
18798 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18803 return resultobj;
18804 fail:
18805 return NULL;
18806 }
18807
18808
18809 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18810 PyObject *resultobj = 0;
18811 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18812 int result;
18813 void *argp1 = 0 ;
18814 int res1 = 0 ;
18815 PyObject *swig_obj[1] ;
18816
18817 if (!args) SWIG_fail;
18818 swig_obj[0] = args;
18819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18820 if (!SWIG_IsOK(res1)) {
18821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18822 }
18823 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18824 {
18825 PyThreadState* __tstate = wxPyBeginAllowThreads();
18826 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18827 wxPyEndAllowThreads(__tstate);
18828 if (PyErr_Occurred()) SWIG_fail;
18829 }
18830 resultobj = SWIG_From_int(static_cast< int >(result));
18831 return resultobj;
18832 fail:
18833 return NULL;
18834 }
18835
18836
18837 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18838 PyObject *resultobj = 0;
18839 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18840 wxString *arg2 = 0 ;
18841 void *argp1 = 0 ;
18842 int res1 = 0 ;
18843 bool temp2 = false ;
18844 PyObject * obj0 = 0 ;
18845 PyObject * obj1 = 0 ;
18846 char * kwnames[] = {
18847 (char *) "self",(char *) "s", NULL
18848 };
18849
18850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18852 if (!SWIG_IsOK(res1)) {
18853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18854 }
18855 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18856 {
18857 arg2 = wxString_in_helper(obj1);
18858 if (arg2 == NULL) SWIG_fail;
18859 temp2 = true;
18860 }
18861 {
18862 PyThreadState* __tstate = wxPyBeginAllowThreads();
18863 (arg1)->SetString((wxString const &)*arg2);
18864 wxPyEndAllowThreads(__tstate);
18865 if (PyErr_Occurred()) SWIG_fail;
18866 }
18867 resultobj = SWIG_Py_Void();
18868 {
18869 if (temp2)
18870 delete arg2;
18871 }
18872 return resultobj;
18873 fail:
18874 {
18875 if (temp2)
18876 delete arg2;
18877 }
18878 return NULL;
18879 }
18880
18881
18882 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18883 PyObject *resultobj = 0;
18884 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18885 wxString result;
18886 void *argp1 = 0 ;
18887 int res1 = 0 ;
18888 PyObject *swig_obj[1] ;
18889
18890 if (!args) SWIG_fail;
18891 swig_obj[0] = args;
18892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18893 if (!SWIG_IsOK(res1)) {
18894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18895 }
18896 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18897 {
18898 PyThreadState* __tstate = wxPyBeginAllowThreads();
18899 result = ((wxCommandEvent const *)arg1)->GetString();
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 {
18904 #if wxUSE_UNICODE
18905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18906 #else
18907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18908 #endif
18909 }
18910 return resultobj;
18911 fail:
18912 return NULL;
18913 }
18914
18915
18916 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18917 PyObject *resultobj = 0;
18918 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18919 bool result;
18920 void *argp1 = 0 ;
18921 int res1 = 0 ;
18922 PyObject *swig_obj[1] ;
18923
18924 if (!args) SWIG_fail;
18925 swig_obj[0] = args;
18926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18927 if (!SWIG_IsOK(res1)) {
18928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18929 }
18930 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18931 {
18932 PyThreadState* __tstate = wxPyBeginAllowThreads();
18933 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18934 wxPyEndAllowThreads(__tstate);
18935 if (PyErr_Occurred()) SWIG_fail;
18936 }
18937 {
18938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18939 }
18940 return resultobj;
18941 fail:
18942 return NULL;
18943 }
18944
18945
18946 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18947 PyObject *resultobj = 0;
18948 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18949 bool result;
18950 void *argp1 = 0 ;
18951 int res1 = 0 ;
18952 PyObject *swig_obj[1] ;
18953
18954 if (!args) SWIG_fail;
18955 swig_obj[0] = args;
18956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18957 if (!SWIG_IsOK(res1)) {
18958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18959 }
18960 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18961 {
18962 PyThreadState* __tstate = wxPyBeginAllowThreads();
18963 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18964 wxPyEndAllowThreads(__tstate);
18965 if (PyErr_Occurred()) SWIG_fail;
18966 }
18967 {
18968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18969 }
18970 return resultobj;
18971 fail:
18972 return NULL;
18973 }
18974
18975
18976 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18977 PyObject *resultobj = 0;
18978 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18979 long arg2 ;
18980 void *argp1 = 0 ;
18981 int res1 = 0 ;
18982 long val2 ;
18983 int ecode2 = 0 ;
18984 PyObject * obj0 = 0 ;
18985 PyObject * obj1 = 0 ;
18986 char * kwnames[] = {
18987 (char *) "self",(char *) "extraLong", NULL
18988 };
18989
18990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18992 if (!SWIG_IsOK(res1)) {
18993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18994 }
18995 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18996 ecode2 = SWIG_AsVal_long(obj1, &val2);
18997 if (!SWIG_IsOK(ecode2)) {
18998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18999 }
19000 arg2 = static_cast< long >(val2);
19001 {
19002 PyThreadState* __tstate = wxPyBeginAllowThreads();
19003 (arg1)->SetExtraLong(arg2);
19004 wxPyEndAllowThreads(__tstate);
19005 if (PyErr_Occurred()) SWIG_fail;
19006 }
19007 resultobj = SWIG_Py_Void();
19008 return resultobj;
19009 fail:
19010 return NULL;
19011 }
19012
19013
19014 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19015 PyObject *resultobj = 0;
19016 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19017 long result;
19018 void *argp1 = 0 ;
19019 int res1 = 0 ;
19020 PyObject *swig_obj[1] ;
19021
19022 if (!args) SWIG_fail;
19023 swig_obj[0] = args;
19024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19025 if (!SWIG_IsOK(res1)) {
19026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19027 }
19028 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19029 {
19030 PyThreadState* __tstate = wxPyBeginAllowThreads();
19031 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19032 wxPyEndAllowThreads(__tstate);
19033 if (PyErr_Occurred()) SWIG_fail;
19034 }
19035 resultobj = SWIG_From_long(static_cast< long >(result));
19036 return resultobj;
19037 fail:
19038 return NULL;
19039 }
19040
19041
19042 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19043 PyObject *resultobj = 0;
19044 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19045 int arg2 ;
19046 void *argp1 = 0 ;
19047 int res1 = 0 ;
19048 int val2 ;
19049 int ecode2 = 0 ;
19050 PyObject * obj0 = 0 ;
19051 PyObject * obj1 = 0 ;
19052 char * kwnames[] = {
19053 (char *) "self",(char *) "i", NULL
19054 };
19055
19056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19058 if (!SWIG_IsOK(res1)) {
19059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19060 }
19061 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19062 ecode2 = SWIG_AsVal_int(obj1, &val2);
19063 if (!SWIG_IsOK(ecode2)) {
19064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19065 }
19066 arg2 = static_cast< int >(val2);
19067 {
19068 PyThreadState* __tstate = wxPyBeginAllowThreads();
19069 (arg1)->SetInt(arg2);
19070 wxPyEndAllowThreads(__tstate);
19071 if (PyErr_Occurred()) SWIG_fail;
19072 }
19073 resultobj = SWIG_Py_Void();
19074 return resultobj;
19075 fail:
19076 return NULL;
19077 }
19078
19079
19080 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19081 PyObject *resultobj = 0;
19082 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19083 int result;
19084 void *argp1 = 0 ;
19085 int res1 = 0 ;
19086 PyObject *swig_obj[1] ;
19087
19088 if (!args) SWIG_fail;
19089 swig_obj[0] = args;
19090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19091 if (!SWIG_IsOK(res1)) {
19092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19093 }
19094 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19095 {
19096 PyThreadState* __tstate = wxPyBeginAllowThreads();
19097 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19098 wxPyEndAllowThreads(__tstate);
19099 if (PyErr_Occurred()) SWIG_fail;
19100 }
19101 resultobj = SWIG_From_int(static_cast< int >(result));
19102 return resultobj;
19103 fail:
19104 return NULL;
19105 }
19106
19107
19108 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19109 PyObject *resultobj = 0;
19110 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19111 PyObject *result = 0 ;
19112 void *argp1 = 0 ;
19113 int res1 = 0 ;
19114 PyObject *swig_obj[1] ;
19115
19116 if (!args) SWIG_fail;
19117 swig_obj[0] = args;
19118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19119 if (!SWIG_IsOK(res1)) {
19120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19121 }
19122 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19123 {
19124 PyThreadState* __tstate = wxPyBeginAllowThreads();
19125 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 resultobj = result;
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19137 PyObject *resultobj = 0;
19138 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19139 PyObject *arg2 = (PyObject *) 0 ;
19140 void *argp1 = 0 ;
19141 int res1 = 0 ;
19142 PyObject * obj0 = 0 ;
19143 PyObject * obj1 = 0 ;
19144 char * kwnames[] = {
19145 (char *) "self",(char *) "clientData", NULL
19146 };
19147
19148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19150 if (!SWIG_IsOK(res1)) {
19151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19152 }
19153 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19154 arg2 = obj1;
19155 {
19156 PyThreadState* __tstate = wxPyBeginAllowThreads();
19157 wxCommandEvent_SetClientData(arg1,arg2);
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 resultobj = SWIG_Py_Void();
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19169 PyObject *resultobj = 0;
19170 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19171 wxEvent *result = 0 ;
19172 void *argp1 = 0 ;
19173 int res1 = 0 ;
19174 PyObject *swig_obj[1] ;
19175
19176 if (!args) SWIG_fail;
19177 swig_obj[0] = args;
19178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19179 if (!SWIG_IsOK(res1)) {
19180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19181 }
19182 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19183 {
19184 PyThreadState* __tstate = wxPyBeginAllowThreads();
19185 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19186 wxPyEndAllowThreads(__tstate);
19187 if (PyErr_Occurred()) SWIG_fail;
19188 }
19189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19190 return resultobj;
19191 fail:
19192 return NULL;
19193 }
19194
19195
19196 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19197 PyObject *obj;
19198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19199 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19200 return SWIG_Py_Void();
19201 }
19202
19203 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19204 return SWIG_Python_InitShadowInstance(args);
19205 }
19206
19207 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19208 PyObject *resultobj = 0;
19209 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19210 int arg2 = (int) 0 ;
19211 wxNotifyEvent *result = 0 ;
19212 int val1 ;
19213 int ecode1 = 0 ;
19214 int val2 ;
19215 int ecode2 = 0 ;
19216 PyObject * obj0 = 0 ;
19217 PyObject * obj1 = 0 ;
19218 char * kwnames[] = {
19219 (char *) "commandType",(char *) "winid", NULL
19220 };
19221
19222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19223 if (obj0) {
19224 ecode1 = SWIG_AsVal_int(obj0, &val1);
19225 if (!SWIG_IsOK(ecode1)) {
19226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19227 }
19228 arg1 = static_cast< wxEventType >(val1);
19229 }
19230 if (obj1) {
19231 ecode2 = SWIG_AsVal_int(obj1, &val2);
19232 if (!SWIG_IsOK(ecode2)) {
19233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19234 }
19235 arg2 = static_cast< int >(val2);
19236 }
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19240 wxPyEndAllowThreads(__tstate);
19241 if (PyErr_Occurred()) SWIG_fail;
19242 }
19243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19251 PyObject *resultobj = 0;
19252 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19253 void *argp1 = 0 ;
19254 int res1 = 0 ;
19255 PyObject *swig_obj[1] ;
19256
19257 if (!args) SWIG_fail;
19258 swig_obj[0] = args;
19259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19260 if (!SWIG_IsOK(res1)) {
19261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19262 }
19263 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 (arg1)->Veto();
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 resultobj = SWIG_Py_Void();
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19278 PyObject *resultobj = 0;
19279 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19280 void *argp1 = 0 ;
19281 int res1 = 0 ;
19282 PyObject *swig_obj[1] ;
19283
19284 if (!args) SWIG_fail;
19285 swig_obj[0] = args;
19286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19287 if (!SWIG_IsOK(res1)) {
19288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19289 }
19290 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 (arg1)->Allow();
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 resultobj = SWIG_Py_Void();
19298 return resultobj;
19299 fail:
19300 return NULL;
19301 }
19302
19303
19304 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19305 PyObject *resultobj = 0;
19306 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19307 bool result;
19308 void *argp1 = 0 ;
19309 int res1 = 0 ;
19310 PyObject *swig_obj[1] ;
19311
19312 if (!args) SWIG_fail;
19313 swig_obj[0] = args;
19314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19315 if (!SWIG_IsOK(res1)) {
19316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19317 }
19318 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 result = (bool)(arg1)->IsAllowed();
19322 wxPyEndAllowThreads(__tstate);
19323 if (PyErr_Occurred()) SWIG_fail;
19324 }
19325 {
19326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19327 }
19328 return resultobj;
19329 fail:
19330 return NULL;
19331 }
19332
19333
19334 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19335 PyObject *obj;
19336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19337 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19338 return SWIG_Py_Void();
19339 }
19340
19341 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19342 return SWIG_Python_InitShadowInstance(args);
19343 }
19344
19345 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19346 PyObject *resultobj = 0;
19347 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19348 int arg2 = (int) 0 ;
19349 int arg3 = (int) 0 ;
19350 int arg4 = (int) 0 ;
19351 wxScrollEvent *result = 0 ;
19352 int val1 ;
19353 int ecode1 = 0 ;
19354 int val2 ;
19355 int ecode2 = 0 ;
19356 int val3 ;
19357 int ecode3 = 0 ;
19358 int val4 ;
19359 int ecode4 = 0 ;
19360 PyObject * obj0 = 0 ;
19361 PyObject * obj1 = 0 ;
19362 PyObject * obj2 = 0 ;
19363 PyObject * obj3 = 0 ;
19364 char * kwnames[] = {
19365 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19366 };
19367
19368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19369 if (obj0) {
19370 ecode1 = SWIG_AsVal_int(obj0, &val1);
19371 if (!SWIG_IsOK(ecode1)) {
19372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19373 }
19374 arg1 = static_cast< wxEventType >(val1);
19375 }
19376 if (obj1) {
19377 ecode2 = SWIG_AsVal_int(obj1, &val2);
19378 if (!SWIG_IsOK(ecode2)) {
19379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19380 }
19381 arg2 = static_cast< int >(val2);
19382 }
19383 if (obj2) {
19384 ecode3 = SWIG_AsVal_int(obj2, &val3);
19385 if (!SWIG_IsOK(ecode3)) {
19386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19387 }
19388 arg3 = static_cast< int >(val3);
19389 }
19390 if (obj3) {
19391 ecode4 = SWIG_AsVal_int(obj3, &val4);
19392 if (!SWIG_IsOK(ecode4)) {
19393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19394 }
19395 arg4 = static_cast< int >(val4);
19396 }
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19400 wxPyEndAllowThreads(__tstate);
19401 if (PyErr_Occurred()) SWIG_fail;
19402 }
19403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19411 PyObject *resultobj = 0;
19412 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19413 int result;
19414 void *argp1 = 0 ;
19415 int res1 = 0 ;
19416 PyObject *swig_obj[1] ;
19417
19418 if (!args) SWIG_fail;
19419 swig_obj[0] = args;
19420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19421 if (!SWIG_IsOK(res1)) {
19422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19423 }
19424 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 resultobj = SWIG_From_int(static_cast< int >(result));
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19439 PyObject *resultobj = 0;
19440 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19441 int result;
19442 void *argp1 = 0 ;
19443 int res1 = 0 ;
19444 PyObject *swig_obj[1] ;
19445
19446 if (!args) SWIG_fail;
19447 swig_obj[0] = args;
19448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19449 if (!SWIG_IsOK(res1)) {
19450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19451 }
19452 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19453 {
19454 PyThreadState* __tstate = wxPyBeginAllowThreads();
19455 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19456 wxPyEndAllowThreads(__tstate);
19457 if (PyErr_Occurred()) SWIG_fail;
19458 }
19459 resultobj = SWIG_From_int(static_cast< int >(result));
19460 return resultobj;
19461 fail:
19462 return NULL;
19463 }
19464
19465
19466 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj = 0;
19468 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19469 int arg2 ;
19470 void *argp1 = 0 ;
19471 int res1 = 0 ;
19472 int val2 ;
19473 int ecode2 = 0 ;
19474 PyObject * obj0 = 0 ;
19475 PyObject * obj1 = 0 ;
19476 char * kwnames[] = {
19477 (char *) "self",(char *) "orient", NULL
19478 };
19479
19480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19482 if (!SWIG_IsOK(res1)) {
19483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19484 }
19485 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19486 ecode2 = SWIG_AsVal_int(obj1, &val2);
19487 if (!SWIG_IsOK(ecode2)) {
19488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19489 }
19490 arg2 = static_cast< int >(val2);
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 (arg1)->SetOrientation(arg2);
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 resultobj = SWIG_Py_Void();
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19505 PyObject *resultobj = 0;
19506 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19507 int arg2 ;
19508 void *argp1 = 0 ;
19509 int res1 = 0 ;
19510 int val2 ;
19511 int ecode2 = 0 ;
19512 PyObject * obj0 = 0 ;
19513 PyObject * obj1 = 0 ;
19514 char * kwnames[] = {
19515 (char *) "self",(char *) "pos", NULL
19516 };
19517
19518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19520 if (!SWIG_IsOK(res1)) {
19521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19522 }
19523 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19524 ecode2 = SWIG_AsVal_int(obj1, &val2);
19525 if (!SWIG_IsOK(ecode2)) {
19526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19527 }
19528 arg2 = static_cast< int >(val2);
19529 {
19530 PyThreadState* __tstate = wxPyBeginAllowThreads();
19531 (arg1)->SetPosition(arg2);
19532 wxPyEndAllowThreads(__tstate);
19533 if (PyErr_Occurred()) SWIG_fail;
19534 }
19535 resultobj = SWIG_Py_Void();
19536 return resultobj;
19537 fail:
19538 return NULL;
19539 }
19540
19541
19542 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19543 PyObject *obj;
19544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19545 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19546 return SWIG_Py_Void();
19547 }
19548
19549 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19550 return SWIG_Python_InitShadowInstance(args);
19551 }
19552
19553 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19554 PyObject *resultobj = 0;
19555 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19556 int arg2 = (int) 0 ;
19557 int arg3 = (int) 0 ;
19558 wxScrollWinEvent *result = 0 ;
19559 int val1 ;
19560 int ecode1 = 0 ;
19561 int val2 ;
19562 int ecode2 = 0 ;
19563 int val3 ;
19564 int ecode3 = 0 ;
19565 PyObject * obj0 = 0 ;
19566 PyObject * obj1 = 0 ;
19567 PyObject * obj2 = 0 ;
19568 char * kwnames[] = {
19569 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19570 };
19571
19572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19573 if (obj0) {
19574 ecode1 = SWIG_AsVal_int(obj0, &val1);
19575 if (!SWIG_IsOK(ecode1)) {
19576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19577 }
19578 arg1 = static_cast< wxEventType >(val1);
19579 }
19580 if (obj1) {
19581 ecode2 = SWIG_AsVal_int(obj1, &val2);
19582 if (!SWIG_IsOK(ecode2)) {
19583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19584 }
19585 arg2 = static_cast< int >(val2);
19586 }
19587 if (obj2) {
19588 ecode3 = SWIG_AsVal_int(obj2, &val3);
19589 if (!SWIG_IsOK(ecode3)) {
19590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19591 }
19592 arg3 = static_cast< int >(val3);
19593 }
19594 {
19595 PyThreadState* __tstate = wxPyBeginAllowThreads();
19596 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19597 wxPyEndAllowThreads(__tstate);
19598 if (PyErr_Occurred()) SWIG_fail;
19599 }
19600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19601 return resultobj;
19602 fail:
19603 return NULL;
19604 }
19605
19606
19607 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19608 PyObject *resultobj = 0;
19609 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19610 int result;
19611 void *argp1 = 0 ;
19612 int res1 = 0 ;
19613 PyObject *swig_obj[1] ;
19614
19615 if (!args) SWIG_fail;
19616 swig_obj[0] = args;
19617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19618 if (!SWIG_IsOK(res1)) {
19619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19620 }
19621 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19625 wxPyEndAllowThreads(__tstate);
19626 if (PyErr_Occurred()) SWIG_fail;
19627 }
19628 resultobj = SWIG_From_int(static_cast< int >(result));
19629 return resultobj;
19630 fail:
19631 return NULL;
19632 }
19633
19634
19635 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19636 PyObject *resultobj = 0;
19637 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19638 int result;
19639 void *argp1 = 0 ;
19640 int res1 = 0 ;
19641 PyObject *swig_obj[1] ;
19642
19643 if (!args) SWIG_fail;
19644 swig_obj[0] = args;
19645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19646 if (!SWIG_IsOK(res1)) {
19647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19648 }
19649 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_From_int(static_cast< int >(result));
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj = 0;
19665 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19666 int arg2 ;
19667 void *argp1 = 0 ;
19668 int res1 = 0 ;
19669 int val2 ;
19670 int ecode2 = 0 ;
19671 PyObject * obj0 = 0 ;
19672 PyObject * obj1 = 0 ;
19673 char * kwnames[] = {
19674 (char *) "self",(char *) "orient", NULL
19675 };
19676
19677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19679 if (!SWIG_IsOK(res1)) {
19680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19681 }
19682 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19683 ecode2 = SWIG_AsVal_int(obj1, &val2);
19684 if (!SWIG_IsOK(ecode2)) {
19685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19686 }
19687 arg2 = static_cast< int >(val2);
19688 {
19689 PyThreadState* __tstate = wxPyBeginAllowThreads();
19690 (arg1)->SetOrientation(arg2);
19691 wxPyEndAllowThreads(__tstate);
19692 if (PyErr_Occurred()) SWIG_fail;
19693 }
19694 resultobj = SWIG_Py_Void();
19695 return resultobj;
19696 fail:
19697 return NULL;
19698 }
19699
19700
19701 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19702 PyObject *resultobj = 0;
19703 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19704 int arg2 ;
19705 void *argp1 = 0 ;
19706 int res1 = 0 ;
19707 int val2 ;
19708 int ecode2 = 0 ;
19709 PyObject * obj0 = 0 ;
19710 PyObject * obj1 = 0 ;
19711 char * kwnames[] = {
19712 (char *) "self",(char *) "pos", NULL
19713 };
19714
19715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19717 if (!SWIG_IsOK(res1)) {
19718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19719 }
19720 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19721 ecode2 = SWIG_AsVal_int(obj1, &val2);
19722 if (!SWIG_IsOK(ecode2)) {
19723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19724 }
19725 arg2 = static_cast< int >(val2);
19726 {
19727 PyThreadState* __tstate = wxPyBeginAllowThreads();
19728 (arg1)->SetPosition(arg2);
19729 wxPyEndAllowThreads(__tstate);
19730 if (PyErr_Occurred()) SWIG_fail;
19731 }
19732 resultobj = SWIG_Py_Void();
19733 return resultobj;
19734 fail:
19735 return NULL;
19736 }
19737
19738
19739 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19740 PyObject *obj;
19741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19742 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19743 return SWIG_Py_Void();
19744 }
19745
19746 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19747 return SWIG_Python_InitShadowInstance(args);
19748 }
19749
19750 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19751 PyObject *resultobj = 0;
19752 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19753 wxMouseEvent *result = 0 ;
19754 int val1 ;
19755 int ecode1 = 0 ;
19756 PyObject * obj0 = 0 ;
19757 char * kwnames[] = {
19758 (char *) "mouseType", NULL
19759 };
19760
19761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19762 if (obj0) {
19763 ecode1 = SWIG_AsVal_int(obj0, &val1);
19764 if (!SWIG_IsOK(ecode1)) {
19765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19766 }
19767 arg1 = static_cast< wxEventType >(val1);
19768 }
19769 {
19770 PyThreadState* __tstate = wxPyBeginAllowThreads();
19771 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19772 wxPyEndAllowThreads(__tstate);
19773 if (PyErr_Occurred()) SWIG_fail;
19774 }
19775 {
19776 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19777 }
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19785 PyObject *resultobj = 0;
19786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19787 bool result;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 PyObject *swig_obj[1] ;
19791
19792 if (!args) SWIG_fail;
19793 swig_obj[0] = args;
19794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19795 if (!SWIG_IsOK(res1)) {
19796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19797 }
19798 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 {
19806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19807 }
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19815 PyObject *resultobj = 0;
19816 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19817 int arg2 = (int) wxMOUSE_BTN_ANY ;
19818 bool result;
19819 void *argp1 = 0 ;
19820 int res1 = 0 ;
19821 int val2 ;
19822 int ecode2 = 0 ;
19823 PyObject * obj0 = 0 ;
19824 PyObject * obj1 = 0 ;
19825 char * kwnames[] = {
19826 (char *) "self",(char *) "but", NULL
19827 };
19828
19829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19831 if (!SWIG_IsOK(res1)) {
19832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19833 }
19834 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19835 if (obj1) {
19836 ecode2 = SWIG_AsVal_int(obj1, &val2);
19837 if (!SWIG_IsOK(ecode2)) {
19838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19839 }
19840 arg2 = static_cast< int >(val2);
19841 }
19842 {
19843 PyThreadState* __tstate = wxPyBeginAllowThreads();
19844 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19845 wxPyEndAllowThreads(__tstate);
19846 if (PyErr_Occurred()) SWIG_fail;
19847 }
19848 {
19849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19850 }
19851 return resultobj;
19852 fail:
19853 return NULL;
19854 }
19855
19856
19857 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19858 PyObject *resultobj = 0;
19859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19860 int arg2 = (int) wxMOUSE_BTN_ANY ;
19861 bool result;
19862 void *argp1 = 0 ;
19863 int res1 = 0 ;
19864 int val2 ;
19865 int ecode2 = 0 ;
19866 PyObject * obj0 = 0 ;
19867 PyObject * obj1 = 0 ;
19868 char * kwnames[] = {
19869 (char *) "self",(char *) "but", NULL
19870 };
19871
19872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19874 if (!SWIG_IsOK(res1)) {
19875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19876 }
19877 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19878 if (obj1) {
19879 ecode2 = SWIG_AsVal_int(obj1, &val2);
19880 if (!SWIG_IsOK(ecode2)) {
19881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19882 }
19883 arg2 = static_cast< int >(val2);
19884 }
19885 {
19886 PyThreadState* __tstate = wxPyBeginAllowThreads();
19887 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19888 wxPyEndAllowThreads(__tstate);
19889 if (PyErr_Occurred()) SWIG_fail;
19890 }
19891 {
19892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19893 }
19894 return resultobj;
19895 fail:
19896 return NULL;
19897 }
19898
19899
19900 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19901 PyObject *resultobj = 0;
19902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19903 int arg2 = (int) wxMOUSE_BTN_ANY ;
19904 bool result;
19905 void *argp1 = 0 ;
19906 int res1 = 0 ;
19907 int val2 ;
19908 int ecode2 = 0 ;
19909 PyObject * obj0 = 0 ;
19910 PyObject * obj1 = 0 ;
19911 char * kwnames[] = {
19912 (char *) "self",(char *) "but", NULL
19913 };
19914
19915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19917 if (!SWIG_IsOK(res1)) {
19918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19919 }
19920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19921 if (obj1) {
19922 ecode2 = SWIG_AsVal_int(obj1, &val2);
19923 if (!SWIG_IsOK(ecode2)) {
19924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19925 }
19926 arg2 = static_cast< int >(val2);
19927 }
19928 {
19929 PyThreadState* __tstate = wxPyBeginAllowThreads();
19930 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19931 wxPyEndAllowThreads(__tstate);
19932 if (PyErr_Occurred()) SWIG_fail;
19933 }
19934 {
19935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19936 }
19937 return resultobj;
19938 fail:
19939 return NULL;
19940 }
19941
19942
19943 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19944 PyObject *resultobj = 0;
19945 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19946 int arg2 ;
19947 bool result;
19948 void *argp1 = 0 ;
19949 int res1 = 0 ;
19950 int val2 ;
19951 int ecode2 = 0 ;
19952 PyObject * obj0 = 0 ;
19953 PyObject * obj1 = 0 ;
19954 char * kwnames[] = {
19955 (char *) "self",(char *) "button", NULL
19956 };
19957
19958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19960 if (!SWIG_IsOK(res1)) {
19961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19962 }
19963 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19964 ecode2 = SWIG_AsVal_int(obj1, &val2);
19965 if (!SWIG_IsOK(ecode2)) {
19966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19967 }
19968 arg2 = static_cast< int >(val2);
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19972 wxPyEndAllowThreads(__tstate);
19973 if (PyErr_Occurred()) SWIG_fail;
19974 }
19975 {
19976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19977 }
19978 return resultobj;
19979 fail:
19980 return NULL;
19981 }
19982
19983
19984 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19985 PyObject *resultobj = 0;
19986 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19987 int arg2 ;
19988 bool result;
19989 void *argp1 = 0 ;
19990 int res1 = 0 ;
19991 int val2 ;
19992 int ecode2 = 0 ;
19993 PyObject * obj0 = 0 ;
19994 PyObject * obj1 = 0 ;
19995 char * kwnames[] = {
19996 (char *) "self",(char *) "but", NULL
19997 };
19998
19999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20001 if (!SWIG_IsOK(res1)) {
20002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20003 }
20004 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20005 ecode2 = SWIG_AsVal_int(obj1, &val2);
20006 if (!SWIG_IsOK(ecode2)) {
20007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20008 }
20009 arg2 = static_cast< int >(val2);
20010 {
20011 PyThreadState* __tstate = wxPyBeginAllowThreads();
20012 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20013 wxPyEndAllowThreads(__tstate);
20014 if (PyErr_Occurred()) SWIG_fail;
20015 }
20016 {
20017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20018 }
20019 return resultobj;
20020 fail:
20021 return NULL;
20022 }
20023
20024
20025 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20026 PyObject *resultobj = 0;
20027 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20028 int result;
20029 void *argp1 = 0 ;
20030 int res1 = 0 ;
20031 PyObject *swig_obj[1] ;
20032
20033 if (!args) SWIG_fail;
20034 swig_obj[0] = args;
20035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20036 if (!SWIG_IsOK(res1)) {
20037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20038 }
20039 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20043 wxPyEndAllowThreads(__tstate);
20044 if (PyErr_Occurred()) SWIG_fail;
20045 }
20046 resultobj = SWIG_From_int(static_cast< int >(result));
20047 return resultobj;
20048 fail:
20049 return NULL;
20050 }
20051
20052
20053 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20054 PyObject *resultobj = 0;
20055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20056 bool result;
20057 void *argp1 = 0 ;
20058 int res1 = 0 ;
20059 PyObject *swig_obj[1] ;
20060
20061 if (!args) SWIG_fail;
20062 swig_obj[0] = args;
20063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20064 if (!SWIG_IsOK(res1)) {
20065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20066 }
20067 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20068 {
20069 PyThreadState* __tstate = wxPyBeginAllowThreads();
20070 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20071 wxPyEndAllowThreads(__tstate);
20072 if (PyErr_Occurred()) SWIG_fail;
20073 }
20074 {
20075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20076 }
20077 return resultobj;
20078 fail:
20079 return NULL;
20080 }
20081
20082
20083 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20084 PyObject *resultobj = 0;
20085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20086 bool result;
20087 void *argp1 = 0 ;
20088 int res1 = 0 ;
20089 PyObject *swig_obj[1] ;
20090
20091 if (!args) SWIG_fail;
20092 swig_obj[0] = args;
20093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20094 if (!SWIG_IsOK(res1)) {
20095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20096 }
20097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20098 {
20099 PyThreadState* __tstate = wxPyBeginAllowThreads();
20100 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20101 wxPyEndAllowThreads(__tstate);
20102 if (PyErr_Occurred()) SWIG_fail;
20103 }
20104 {
20105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20106 }
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20114 PyObject *resultobj = 0;
20115 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20116 bool result;
20117 void *argp1 = 0 ;
20118 int res1 = 0 ;
20119 PyObject *swig_obj[1] ;
20120
20121 if (!args) SWIG_fail;
20122 swig_obj[0] = args;
20123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20124 if (!SWIG_IsOK(res1)) {
20125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20126 }
20127 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20128 {
20129 PyThreadState* __tstate = wxPyBeginAllowThreads();
20130 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20131 wxPyEndAllowThreads(__tstate);
20132 if (PyErr_Occurred()) SWIG_fail;
20133 }
20134 {
20135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20136 }
20137 return resultobj;
20138 fail:
20139 return NULL;
20140 }
20141
20142
20143 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20144 PyObject *resultobj = 0;
20145 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20146 bool result;
20147 void *argp1 = 0 ;
20148 int res1 = 0 ;
20149 PyObject *swig_obj[1] ;
20150
20151 if (!args) SWIG_fail;
20152 swig_obj[0] = args;
20153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20154 if (!SWIG_IsOK(res1)) {
20155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20156 }
20157 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20158 {
20159 PyThreadState* __tstate = wxPyBeginAllowThreads();
20160 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20161 wxPyEndAllowThreads(__tstate);
20162 if (PyErr_Occurred()) SWIG_fail;
20163 }
20164 {
20165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20166 }
20167 return resultobj;
20168 fail:
20169 return NULL;
20170 }
20171
20172
20173 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20174 PyObject *resultobj = 0;
20175 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20176 bool result;
20177 void *argp1 = 0 ;
20178 int res1 = 0 ;
20179 PyObject *swig_obj[1] ;
20180
20181 if (!args) SWIG_fail;
20182 swig_obj[0] = args;
20183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20184 if (!SWIG_IsOK(res1)) {
20185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20186 }
20187 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20191 wxPyEndAllowThreads(__tstate);
20192 if (PyErr_Occurred()) SWIG_fail;
20193 }
20194 {
20195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20196 }
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20204 PyObject *resultobj = 0;
20205 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20206 bool result;
20207 void *argp1 = 0 ;
20208 int res1 = 0 ;
20209 PyObject *swig_obj[1] ;
20210
20211 if (!args) SWIG_fail;
20212 swig_obj[0] = args;
20213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20214 if (!SWIG_IsOK(res1)) {
20215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20216 }
20217 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20218 {
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 {
20225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20226 }
20227 return resultobj;
20228 fail:
20229 return NULL;
20230 }
20231
20232
20233 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20234 PyObject *resultobj = 0;
20235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20236 bool result;
20237 void *argp1 = 0 ;
20238 int res1 = 0 ;
20239 PyObject *swig_obj[1] ;
20240
20241 if (!args) SWIG_fail;
20242 swig_obj[0] = args;
20243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20244 if (!SWIG_IsOK(res1)) {
20245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20246 }
20247 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20248 {
20249 PyThreadState* __tstate = wxPyBeginAllowThreads();
20250 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20251 wxPyEndAllowThreads(__tstate);
20252 if (PyErr_Occurred()) SWIG_fail;
20253 }
20254 {
20255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20256 }
20257 return resultobj;
20258 fail:
20259 return NULL;
20260 }
20261
20262
20263 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20264 PyObject *resultobj = 0;
20265 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20266 bool result;
20267 void *argp1 = 0 ;
20268 int res1 = 0 ;
20269 PyObject *swig_obj[1] ;
20270
20271 if (!args) SWIG_fail;
20272 swig_obj[0] = args;
20273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20274 if (!SWIG_IsOK(res1)) {
20275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20276 }
20277 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20278 {
20279 PyThreadState* __tstate = wxPyBeginAllowThreads();
20280 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20281 wxPyEndAllowThreads(__tstate);
20282 if (PyErr_Occurred()) SWIG_fail;
20283 }
20284 {
20285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20286 }
20287 return resultobj;
20288 fail:
20289 return NULL;
20290 }
20291
20292
20293 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20294 PyObject *resultobj = 0;
20295 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20296 bool result;
20297 void *argp1 = 0 ;
20298 int res1 = 0 ;
20299 PyObject *swig_obj[1] ;
20300
20301 if (!args) SWIG_fail;
20302 swig_obj[0] = args;
20303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20304 if (!SWIG_IsOK(res1)) {
20305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20306 }
20307 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 {
20315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20316 }
20317 return resultobj;
20318 fail:
20319 return NULL;
20320 }
20321
20322
20323 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20324 PyObject *resultobj = 0;
20325 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20326 bool result;
20327 void *argp1 = 0 ;
20328 int res1 = 0 ;
20329 PyObject *swig_obj[1] ;
20330
20331 if (!args) SWIG_fail;
20332 swig_obj[0] = args;
20333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20334 if (!SWIG_IsOK(res1)) {
20335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20336 }
20337 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20338 {
20339 PyThreadState* __tstate = wxPyBeginAllowThreads();
20340 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20341 wxPyEndAllowThreads(__tstate);
20342 if (PyErr_Occurred()) SWIG_fail;
20343 }
20344 {
20345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20346 }
20347 return resultobj;
20348 fail:
20349 return NULL;
20350 }
20351
20352
20353 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20354 PyObject *resultobj = 0;
20355 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20356 bool result;
20357 void *argp1 = 0 ;
20358 int res1 = 0 ;
20359 PyObject *swig_obj[1] ;
20360
20361 if (!args) SWIG_fail;
20362 swig_obj[0] = args;
20363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20364 if (!SWIG_IsOK(res1)) {
20365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20366 }
20367 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20368 {
20369 PyThreadState* __tstate = wxPyBeginAllowThreads();
20370 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20371 wxPyEndAllowThreads(__tstate);
20372 if (PyErr_Occurred()) SWIG_fail;
20373 }
20374 {
20375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20376 }
20377 return resultobj;
20378 fail:
20379 return NULL;
20380 }
20381
20382
20383 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20384 PyObject *resultobj = 0;
20385 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20386 bool result;
20387 void *argp1 = 0 ;
20388 int res1 = 0 ;
20389 PyObject *swig_obj[1] ;
20390
20391 if (!args) SWIG_fail;
20392 swig_obj[0] = args;
20393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20394 if (!SWIG_IsOK(res1)) {
20395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20396 }
20397 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20401 wxPyEndAllowThreads(__tstate);
20402 if (PyErr_Occurred()) SWIG_fail;
20403 }
20404 {
20405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20406 }
20407 return resultobj;
20408 fail:
20409 return NULL;
20410 }
20411
20412
20413 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20414 PyObject *resultobj = 0;
20415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20416 bool result;
20417 void *argp1 = 0 ;
20418 int res1 = 0 ;
20419 PyObject *swig_obj[1] ;
20420
20421 if (!args) SWIG_fail;
20422 swig_obj[0] = args;
20423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20424 if (!SWIG_IsOK(res1)) {
20425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20426 }
20427 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20428 {
20429 PyThreadState* __tstate = wxPyBeginAllowThreads();
20430 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20431 wxPyEndAllowThreads(__tstate);
20432 if (PyErr_Occurred()) SWIG_fail;
20433 }
20434 {
20435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20436 }
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20444 PyObject *resultobj = 0;
20445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20446 bool result;
20447 void *argp1 = 0 ;
20448 int res1 = 0 ;
20449 PyObject *swig_obj[1] ;
20450
20451 if (!args) SWIG_fail;
20452 swig_obj[0] = args;
20453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20454 if (!SWIG_IsOK(res1)) {
20455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20456 }
20457 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20458 {
20459 PyThreadState* __tstate = wxPyBeginAllowThreads();
20460 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20461 wxPyEndAllowThreads(__tstate);
20462 if (PyErr_Occurred()) SWIG_fail;
20463 }
20464 {
20465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20466 }
20467 return resultobj;
20468 fail:
20469 return NULL;
20470 }
20471
20472
20473 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20474 PyObject *resultobj = 0;
20475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20476 bool result;
20477 void *argp1 = 0 ;
20478 int res1 = 0 ;
20479 PyObject *swig_obj[1] ;
20480
20481 if (!args) SWIG_fail;
20482 swig_obj[0] = args;
20483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20484 if (!SWIG_IsOK(res1)) {
20485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20486 }
20487 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20488 {
20489 PyThreadState* __tstate = wxPyBeginAllowThreads();
20490 result = (bool)(arg1)->LeftIsDown();
20491 wxPyEndAllowThreads(__tstate);
20492 if (PyErr_Occurred()) SWIG_fail;
20493 }
20494 {
20495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20496 }
20497 return resultobj;
20498 fail:
20499 return NULL;
20500 }
20501
20502
20503 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20504 PyObject *resultobj = 0;
20505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20506 bool result;
20507 void *argp1 = 0 ;
20508 int res1 = 0 ;
20509 PyObject *swig_obj[1] ;
20510
20511 if (!args) SWIG_fail;
20512 swig_obj[0] = args;
20513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20514 if (!SWIG_IsOK(res1)) {
20515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20516 }
20517 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 result = (bool)(arg1)->MiddleIsDown();
20521 wxPyEndAllowThreads(__tstate);
20522 if (PyErr_Occurred()) SWIG_fail;
20523 }
20524 {
20525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20526 }
20527 return resultobj;
20528 fail:
20529 return NULL;
20530 }
20531
20532
20533 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20534 PyObject *resultobj = 0;
20535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20536 bool result;
20537 void *argp1 = 0 ;
20538 int res1 = 0 ;
20539 PyObject *swig_obj[1] ;
20540
20541 if (!args) SWIG_fail;
20542 swig_obj[0] = args;
20543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20544 if (!SWIG_IsOK(res1)) {
20545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20546 }
20547 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20548 {
20549 PyThreadState* __tstate = wxPyBeginAllowThreads();
20550 result = (bool)(arg1)->RightIsDown();
20551 wxPyEndAllowThreads(__tstate);
20552 if (PyErr_Occurred()) SWIG_fail;
20553 }
20554 {
20555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20556 }
20557 return resultobj;
20558 fail:
20559 return NULL;
20560 }
20561
20562
20563 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20564 PyObject *resultobj = 0;
20565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20566 bool result;
20567 void *argp1 = 0 ;
20568 int res1 = 0 ;
20569 PyObject *swig_obj[1] ;
20570
20571 if (!args) SWIG_fail;
20572 swig_obj[0] = args;
20573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20574 if (!SWIG_IsOK(res1)) {
20575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20576 }
20577 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20578 {
20579 PyThreadState* __tstate = wxPyBeginAllowThreads();
20580 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20581 wxPyEndAllowThreads(__tstate);
20582 if (PyErr_Occurred()) SWIG_fail;
20583 }
20584 {
20585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20586 }
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20594 PyObject *resultobj = 0;
20595 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20596 bool result;
20597 void *argp1 = 0 ;
20598 int res1 = 0 ;
20599 PyObject *swig_obj[1] ;
20600
20601 if (!args) SWIG_fail;
20602 swig_obj[0] = args;
20603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20604 if (!SWIG_IsOK(res1)) {
20605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20606 }
20607 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20608 {
20609 PyThreadState* __tstate = wxPyBeginAllowThreads();
20610 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 {
20615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20616 }
20617 return resultobj;
20618 fail:
20619 return NULL;
20620 }
20621
20622
20623 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20624 PyObject *resultobj = 0;
20625 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20626 bool result;
20627 void *argp1 = 0 ;
20628 int res1 = 0 ;
20629 PyObject *swig_obj[1] ;
20630
20631 if (!args) SWIG_fail;
20632 swig_obj[0] = args;
20633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20634 if (!SWIG_IsOK(res1)) {
20635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20636 }
20637 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20638 {
20639 PyThreadState* __tstate = wxPyBeginAllowThreads();
20640 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20641 wxPyEndAllowThreads(__tstate);
20642 if (PyErr_Occurred()) SWIG_fail;
20643 }
20644 {
20645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20646 }
20647 return resultobj;
20648 fail:
20649 return NULL;
20650 }
20651
20652
20653 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20654 PyObject *resultobj = 0;
20655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20656 bool result;
20657 void *argp1 = 0 ;
20658 int res1 = 0 ;
20659 PyObject *swig_obj[1] ;
20660
20661 if (!args) SWIG_fail;
20662 swig_obj[0] = args;
20663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20664 if (!SWIG_IsOK(res1)) {
20665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20666 }
20667 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20668 {
20669 PyThreadState* __tstate = wxPyBeginAllowThreads();
20670 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20671 wxPyEndAllowThreads(__tstate);
20672 if (PyErr_Occurred()) SWIG_fail;
20673 }
20674 {
20675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20676 }
20677 return resultobj;
20678 fail:
20679 return NULL;
20680 }
20681
20682
20683 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20684 PyObject *resultobj = 0;
20685 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20686 wxPoint result;
20687 void *argp1 = 0 ;
20688 int res1 = 0 ;
20689 PyObject *swig_obj[1] ;
20690
20691 if (!args) SWIG_fail;
20692 swig_obj[0] = args;
20693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20694 if (!SWIG_IsOK(res1)) {
20695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20696 }
20697 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20698 {
20699 PyThreadState* __tstate = wxPyBeginAllowThreads();
20700 result = (arg1)->GetPosition();
20701 wxPyEndAllowThreads(__tstate);
20702 if (PyErr_Occurred()) SWIG_fail;
20703 }
20704 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20705 return resultobj;
20706 fail:
20707 return NULL;
20708 }
20709
20710
20711 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20712 PyObject *resultobj = 0;
20713 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20714 long *arg2 = (long *) 0 ;
20715 long *arg3 = (long *) 0 ;
20716 void *argp1 = 0 ;
20717 int res1 = 0 ;
20718 long temp2 ;
20719 int res2 = SWIG_TMPOBJ ;
20720 long temp3 ;
20721 int res3 = SWIG_TMPOBJ ;
20722 PyObject *swig_obj[1] ;
20723
20724 arg2 = &temp2;
20725 arg3 = &temp3;
20726 if (!args) SWIG_fail;
20727 swig_obj[0] = args;
20728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20729 if (!SWIG_IsOK(res1)) {
20730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20731 }
20732 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20733 {
20734 PyThreadState* __tstate = wxPyBeginAllowThreads();
20735 (arg1)->GetPosition(arg2,arg3);
20736 wxPyEndAllowThreads(__tstate);
20737 if (PyErr_Occurred()) SWIG_fail;
20738 }
20739 resultobj = SWIG_Py_Void();
20740 if (SWIG_IsTmpObj(res2)) {
20741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20742 } else {
20743 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20745 }
20746 if (SWIG_IsTmpObj(res3)) {
20747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20748 } else {
20749 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20751 }
20752 return resultobj;
20753 fail:
20754 return NULL;
20755 }
20756
20757
20758 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20759 PyObject *resultobj = 0;
20760 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20761 wxDC *arg2 = 0 ;
20762 wxPoint result;
20763 void *argp1 = 0 ;
20764 int res1 = 0 ;
20765 void *argp2 = 0 ;
20766 int res2 = 0 ;
20767 PyObject * obj0 = 0 ;
20768 PyObject * obj1 = 0 ;
20769 char * kwnames[] = {
20770 (char *) "self",(char *) "dc", NULL
20771 };
20772
20773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20775 if (!SWIG_IsOK(res1)) {
20776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20777 }
20778 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20779 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20780 if (!SWIG_IsOK(res2)) {
20781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20782 }
20783 if (!argp2) {
20784 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20785 }
20786 arg2 = reinterpret_cast< wxDC * >(argp2);
20787 {
20788 PyThreadState* __tstate = wxPyBeginAllowThreads();
20789 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20790 wxPyEndAllowThreads(__tstate);
20791 if (PyErr_Occurred()) SWIG_fail;
20792 }
20793 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20794 return resultobj;
20795 fail:
20796 return NULL;
20797 }
20798
20799
20800 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20801 PyObject *resultobj = 0;
20802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20803 int result;
20804 void *argp1 = 0 ;
20805 int res1 = 0 ;
20806 PyObject *swig_obj[1] ;
20807
20808 if (!args) SWIG_fail;
20809 swig_obj[0] = args;
20810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20811 if (!SWIG_IsOK(res1)) {
20812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20813 }
20814 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 result = (int)((wxMouseEvent const *)arg1)->GetX();
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 resultobj = SWIG_From_int(static_cast< int >(result));
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20829 PyObject *resultobj = 0;
20830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20831 int result;
20832 void *argp1 = 0 ;
20833 int res1 = 0 ;
20834 PyObject *swig_obj[1] ;
20835
20836 if (!args) SWIG_fail;
20837 swig_obj[0] = args;
20838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20839 if (!SWIG_IsOK(res1)) {
20840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20841 }
20842 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20843 {
20844 PyThreadState* __tstate = wxPyBeginAllowThreads();
20845 result = (int)((wxMouseEvent const *)arg1)->GetY();
20846 wxPyEndAllowThreads(__tstate);
20847 if (PyErr_Occurred()) SWIG_fail;
20848 }
20849 resultobj = SWIG_From_int(static_cast< int >(result));
20850 return resultobj;
20851 fail:
20852 return NULL;
20853 }
20854
20855
20856 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20857 PyObject *resultobj = 0;
20858 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20859 int result;
20860 void *argp1 = 0 ;
20861 int res1 = 0 ;
20862 PyObject *swig_obj[1] ;
20863
20864 if (!args) SWIG_fail;
20865 swig_obj[0] = args;
20866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20867 if (!SWIG_IsOK(res1)) {
20868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20869 }
20870 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 resultobj = SWIG_From_int(static_cast< int >(result));
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20885 PyObject *resultobj = 0;
20886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20887 int result;
20888 void *argp1 = 0 ;
20889 int res1 = 0 ;
20890 PyObject *swig_obj[1] ;
20891
20892 if (!args) SWIG_fail;
20893 swig_obj[0] = args;
20894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20895 if (!SWIG_IsOK(res1)) {
20896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20897 }
20898 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 resultobj = SWIG_From_int(static_cast< int >(result));
20906 return resultobj;
20907 fail:
20908 return NULL;
20909 }
20910
20911
20912 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20913 PyObject *resultobj = 0;
20914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20915 int result;
20916 void *argp1 = 0 ;
20917 int res1 = 0 ;
20918 PyObject *swig_obj[1] ;
20919
20920 if (!args) SWIG_fail;
20921 swig_obj[0] = args;
20922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20923 if (!SWIG_IsOK(res1)) {
20924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20925 }
20926 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20927 {
20928 PyThreadState* __tstate = wxPyBeginAllowThreads();
20929 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 resultobj = SWIG_From_int(static_cast< int >(result));
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20941 PyObject *resultobj = 0;
20942 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20943 bool result;
20944 void *argp1 = 0 ;
20945 int res1 = 0 ;
20946 PyObject *swig_obj[1] ;
20947
20948 if (!args) SWIG_fail;
20949 swig_obj[0] = args;
20950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20951 if (!SWIG_IsOK(res1)) {
20952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20953 }
20954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20955 {
20956 PyThreadState* __tstate = wxPyBeginAllowThreads();
20957 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 {
20962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20963 }
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20971 PyObject *resultobj = 0;
20972 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20973 int arg2 ;
20974 void *argp1 = 0 ;
20975 int res1 = 0 ;
20976 int val2 ;
20977 int ecode2 = 0 ;
20978 PyObject *swig_obj[2] ;
20979
20980 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20982 if (!SWIG_IsOK(res1)) {
20983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20984 }
20985 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20986 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20987 if (!SWIG_IsOK(ecode2)) {
20988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20989 }
20990 arg2 = static_cast< int >(val2);
20991 if (arg1) (arg1)->m_x = arg2;
20992
20993 resultobj = SWIG_Py_Void();
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21001 PyObject *resultobj = 0;
21002 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21003 int result;
21004 void *argp1 = 0 ;
21005 int res1 = 0 ;
21006 PyObject *swig_obj[1] ;
21007
21008 if (!args) SWIG_fail;
21009 swig_obj[0] = args;
21010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21011 if (!SWIG_IsOK(res1)) {
21012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21013 }
21014 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21015 result = (int) ((arg1)->m_x);
21016 resultobj = SWIG_From_int(static_cast< int >(result));
21017 return resultobj;
21018 fail:
21019 return NULL;
21020 }
21021
21022
21023 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21024 PyObject *resultobj = 0;
21025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21026 int arg2 ;
21027 void *argp1 = 0 ;
21028 int res1 = 0 ;
21029 int val2 ;
21030 int ecode2 = 0 ;
21031 PyObject *swig_obj[2] ;
21032
21033 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21035 if (!SWIG_IsOK(res1)) {
21036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21037 }
21038 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21039 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21040 if (!SWIG_IsOK(ecode2)) {
21041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21042 }
21043 arg2 = static_cast< int >(val2);
21044 if (arg1) (arg1)->m_y = arg2;
21045
21046 resultobj = SWIG_Py_Void();
21047 return resultobj;
21048 fail:
21049 return NULL;
21050 }
21051
21052
21053 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21054 PyObject *resultobj = 0;
21055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21056 int result;
21057 void *argp1 = 0 ;
21058 int res1 = 0 ;
21059 PyObject *swig_obj[1] ;
21060
21061 if (!args) SWIG_fail;
21062 swig_obj[0] = args;
21063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21064 if (!SWIG_IsOK(res1)) {
21065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21066 }
21067 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21068 result = (int) ((arg1)->m_y);
21069 resultobj = SWIG_From_int(static_cast< int >(result));
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21077 PyObject *resultobj = 0;
21078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21079 bool arg2 ;
21080 void *argp1 = 0 ;
21081 int res1 = 0 ;
21082 bool val2 ;
21083 int ecode2 = 0 ;
21084 PyObject *swig_obj[2] ;
21085
21086 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21090 }
21091 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21092 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21093 if (!SWIG_IsOK(ecode2)) {
21094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21095 }
21096 arg2 = static_cast< bool >(val2);
21097 if (arg1) (arg1)->m_leftDown = arg2;
21098
21099 resultobj = SWIG_Py_Void();
21100 return resultobj;
21101 fail:
21102 return NULL;
21103 }
21104
21105
21106 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21107 PyObject *resultobj = 0;
21108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21109 bool result;
21110 void *argp1 = 0 ;
21111 int res1 = 0 ;
21112 PyObject *swig_obj[1] ;
21113
21114 if (!args) SWIG_fail;
21115 swig_obj[0] = args;
21116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21117 if (!SWIG_IsOK(res1)) {
21118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21119 }
21120 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21121 result = (bool) ((arg1)->m_leftDown);
21122 {
21123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21124 }
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21132 PyObject *resultobj = 0;
21133 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21134 bool arg2 ;
21135 void *argp1 = 0 ;
21136 int res1 = 0 ;
21137 bool val2 ;
21138 int ecode2 = 0 ;
21139 PyObject *swig_obj[2] ;
21140
21141 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21143 if (!SWIG_IsOK(res1)) {
21144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21145 }
21146 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21147 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21148 if (!SWIG_IsOK(ecode2)) {
21149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21150 }
21151 arg2 = static_cast< bool >(val2);
21152 if (arg1) (arg1)->m_middleDown = arg2;
21153
21154 resultobj = SWIG_Py_Void();
21155 return resultobj;
21156 fail:
21157 return NULL;
21158 }
21159
21160
21161 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21162 PyObject *resultobj = 0;
21163 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21164 bool result;
21165 void *argp1 = 0 ;
21166 int res1 = 0 ;
21167 PyObject *swig_obj[1] ;
21168
21169 if (!args) SWIG_fail;
21170 swig_obj[0] = args;
21171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21172 if (!SWIG_IsOK(res1)) {
21173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21174 }
21175 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21176 result = (bool) ((arg1)->m_middleDown);
21177 {
21178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21179 }
21180 return resultobj;
21181 fail:
21182 return NULL;
21183 }
21184
21185
21186 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21187 PyObject *resultobj = 0;
21188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21189 bool arg2 ;
21190 void *argp1 = 0 ;
21191 int res1 = 0 ;
21192 bool val2 ;
21193 int ecode2 = 0 ;
21194 PyObject *swig_obj[2] ;
21195
21196 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21198 if (!SWIG_IsOK(res1)) {
21199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21200 }
21201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21202 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21203 if (!SWIG_IsOK(ecode2)) {
21204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21205 }
21206 arg2 = static_cast< bool >(val2);
21207 if (arg1) (arg1)->m_rightDown = arg2;
21208
21209 resultobj = SWIG_Py_Void();
21210 return resultobj;
21211 fail:
21212 return NULL;
21213 }
21214
21215
21216 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21217 PyObject *resultobj = 0;
21218 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21219 bool result;
21220 void *argp1 = 0 ;
21221 int res1 = 0 ;
21222 PyObject *swig_obj[1] ;
21223
21224 if (!args) SWIG_fail;
21225 swig_obj[0] = args;
21226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21227 if (!SWIG_IsOK(res1)) {
21228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21229 }
21230 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21231 result = (bool) ((arg1)->m_rightDown);
21232 {
21233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21234 }
21235 return resultobj;
21236 fail:
21237 return NULL;
21238 }
21239
21240
21241 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21242 PyObject *resultobj = 0;
21243 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21244 bool arg2 ;
21245 void *argp1 = 0 ;
21246 int res1 = 0 ;
21247 bool val2 ;
21248 int ecode2 = 0 ;
21249 PyObject *swig_obj[2] ;
21250
21251 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21255 }
21256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21257 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21258 if (!SWIG_IsOK(ecode2)) {
21259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21260 }
21261 arg2 = static_cast< bool >(val2);
21262 if (arg1) (arg1)->m_controlDown = arg2;
21263
21264 resultobj = SWIG_Py_Void();
21265 return resultobj;
21266 fail:
21267 return NULL;
21268 }
21269
21270
21271 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21272 PyObject *resultobj = 0;
21273 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21274 bool result;
21275 void *argp1 = 0 ;
21276 int res1 = 0 ;
21277 PyObject *swig_obj[1] ;
21278
21279 if (!args) SWIG_fail;
21280 swig_obj[0] = args;
21281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21282 if (!SWIG_IsOK(res1)) {
21283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21284 }
21285 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21286 result = (bool) ((arg1)->m_controlDown);
21287 {
21288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21289 }
21290 return resultobj;
21291 fail:
21292 return NULL;
21293 }
21294
21295
21296 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21297 PyObject *resultobj = 0;
21298 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21299 bool arg2 ;
21300 void *argp1 = 0 ;
21301 int res1 = 0 ;
21302 bool val2 ;
21303 int ecode2 = 0 ;
21304 PyObject *swig_obj[2] ;
21305
21306 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21308 if (!SWIG_IsOK(res1)) {
21309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21310 }
21311 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21312 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21313 if (!SWIG_IsOK(ecode2)) {
21314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21315 }
21316 arg2 = static_cast< bool >(val2);
21317 if (arg1) (arg1)->m_shiftDown = arg2;
21318
21319 resultobj = SWIG_Py_Void();
21320 return resultobj;
21321 fail:
21322 return NULL;
21323 }
21324
21325
21326 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21327 PyObject *resultobj = 0;
21328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21329 bool result;
21330 void *argp1 = 0 ;
21331 int res1 = 0 ;
21332 PyObject *swig_obj[1] ;
21333
21334 if (!args) SWIG_fail;
21335 swig_obj[0] = args;
21336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21337 if (!SWIG_IsOK(res1)) {
21338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21339 }
21340 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21341 result = (bool) ((arg1)->m_shiftDown);
21342 {
21343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21344 }
21345 return resultobj;
21346 fail:
21347 return NULL;
21348 }
21349
21350
21351 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21352 PyObject *resultobj = 0;
21353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21354 bool arg2 ;
21355 void *argp1 = 0 ;
21356 int res1 = 0 ;
21357 bool val2 ;
21358 int ecode2 = 0 ;
21359 PyObject *swig_obj[2] ;
21360
21361 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21363 if (!SWIG_IsOK(res1)) {
21364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21365 }
21366 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21367 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21368 if (!SWIG_IsOK(ecode2)) {
21369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21370 }
21371 arg2 = static_cast< bool >(val2);
21372 if (arg1) (arg1)->m_altDown = arg2;
21373
21374 resultobj = SWIG_Py_Void();
21375 return resultobj;
21376 fail:
21377 return NULL;
21378 }
21379
21380
21381 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21382 PyObject *resultobj = 0;
21383 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21384 bool result;
21385 void *argp1 = 0 ;
21386 int res1 = 0 ;
21387 PyObject *swig_obj[1] ;
21388
21389 if (!args) SWIG_fail;
21390 swig_obj[0] = args;
21391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21392 if (!SWIG_IsOK(res1)) {
21393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21394 }
21395 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21396 result = (bool) ((arg1)->m_altDown);
21397 {
21398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21399 }
21400 return resultobj;
21401 fail:
21402 return NULL;
21403 }
21404
21405
21406 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21407 PyObject *resultobj = 0;
21408 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21409 bool arg2 ;
21410 void *argp1 = 0 ;
21411 int res1 = 0 ;
21412 bool val2 ;
21413 int ecode2 = 0 ;
21414 PyObject *swig_obj[2] ;
21415
21416 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21418 if (!SWIG_IsOK(res1)) {
21419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21420 }
21421 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21422 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21423 if (!SWIG_IsOK(ecode2)) {
21424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21425 }
21426 arg2 = static_cast< bool >(val2);
21427 if (arg1) (arg1)->m_metaDown = arg2;
21428
21429 resultobj = SWIG_Py_Void();
21430 return resultobj;
21431 fail:
21432 return NULL;
21433 }
21434
21435
21436 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21437 PyObject *resultobj = 0;
21438 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21439 bool result;
21440 void *argp1 = 0 ;
21441 int res1 = 0 ;
21442 PyObject *swig_obj[1] ;
21443
21444 if (!args) SWIG_fail;
21445 swig_obj[0] = args;
21446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21447 if (!SWIG_IsOK(res1)) {
21448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21449 }
21450 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21451 result = (bool) ((arg1)->m_metaDown);
21452 {
21453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21454 }
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21462 PyObject *resultobj = 0;
21463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21464 int arg2 ;
21465 void *argp1 = 0 ;
21466 int res1 = 0 ;
21467 int val2 ;
21468 int ecode2 = 0 ;
21469 PyObject *swig_obj[2] ;
21470
21471 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21473 if (!SWIG_IsOK(res1)) {
21474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21475 }
21476 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21477 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21478 if (!SWIG_IsOK(ecode2)) {
21479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21480 }
21481 arg2 = static_cast< int >(val2);
21482 if (arg1) (arg1)->m_wheelRotation = arg2;
21483
21484 resultobj = SWIG_Py_Void();
21485 return resultobj;
21486 fail:
21487 return NULL;
21488 }
21489
21490
21491 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21492 PyObject *resultobj = 0;
21493 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21494 int result;
21495 void *argp1 = 0 ;
21496 int res1 = 0 ;
21497 PyObject *swig_obj[1] ;
21498
21499 if (!args) SWIG_fail;
21500 swig_obj[0] = args;
21501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21502 if (!SWIG_IsOK(res1)) {
21503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21504 }
21505 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21506 result = (int) ((arg1)->m_wheelRotation);
21507 resultobj = SWIG_From_int(static_cast< int >(result));
21508 return resultobj;
21509 fail:
21510 return NULL;
21511 }
21512
21513
21514 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21515 PyObject *resultobj = 0;
21516 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21517 int arg2 ;
21518 void *argp1 = 0 ;
21519 int res1 = 0 ;
21520 int val2 ;
21521 int ecode2 = 0 ;
21522 PyObject *swig_obj[2] ;
21523
21524 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21526 if (!SWIG_IsOK(res1)) {
21527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21528 }
21529 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21530 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21531 if (!SWIG_IsOK(ecode2)) {
21532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21533 }
21534 arg2 = static_cast< int >(val2);
21535 if (arg1) (arg1)->m_wheelDelta = arg2;
21536
21537 resultobj = SWIG_Py_Void();
21538 return resultobj;
21539 fail:
21540 return NULL;
21541 }
21542
21543
21544 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21545 PyObject *resultobj = 0;
21546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21547 int result;
21548 void *argp1 = 0 ;
21549 int res1 = 0 ;
21550 PyObject *swig_obj[1] ;
21551
21552 if (!args) SWIG_fail;
21553 swig_obj[0] = args;
21554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21555 if (!SWIG_IsOK(res1)) {
21556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21557 }
21558 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21559 result = (int) ((arg1)->m_wheelDelta);
21560 resultobj = SWIG_From_int(static_cast< int >(result));
21561 return resultobj;
21562 fail:
21563 return NULL;
21564 }
21565
21566
21567 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21568 PyObject *resultobj = 0;
21569 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21570 int arg2 ;
21571 void *argp1 = 0 ;
21572 int res1 = 0 ;
21573 int val2 ;
21574 int ecode2 = 0 ;
21575 PyObject *swig_obj[2] ;
21576
21577 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21579 if (!SWIG_IsOK(res1)) {
21580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21581 }
21582 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21583 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21584 if (!SWIG_IsOK(ecode2)) {
21585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21586 }
21587 arg2 = static_cast< int >(val2);
21588 if (arg1) (arg1)->m_linesPerAction = arg2;
21589
21590 resultobj = SWIG_Py_Void();
21591 return resultobj;
21592 fail:
21593 return NULL;
21594 }
21595
21596
21597 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21598 PyObject *resultobj = 0;
21599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21600 int result;
21601 void *argp1 = 0 ;
21602 int res1 = 0 ;
21603 PyObject *swig_obj[1] ;
21604
21605 if (!args) SWIG_fail;
21606 swig_obj[0] = args;
21607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21608 if (!SWIG_IsOK(res1)) {
21609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21610 }
21611 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21612 result = (int) ((arg1)->m_linesPerAction);
21613 resultobj = SWIG_From_int(static_cast< int >(result));
21614 return resultobj;
21615 fail:
21616 return NULL;
21617 }
21618
21619
21620 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21621 PyObject *obj;
21622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21623 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21624 return SWIG_Py_Void();
21625 }
21626
21627 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21628 return SWIG_Python_InitShadowInstance(args);
21629 }
21630
21631 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21632 PyObject *resultobj = 0;
21633 int arg1 = (int) 0 ;
21634 int arg2 = (int) 0 ;
21635 wxSetCursorEvent *result = 0 ;
21636 int val1 ;
21637 int ecode1 = 0 ;
21638 int val2 ;
21639 int ecode2 = 0 ;
21640 PyObject * obj0 = 0 ;
21641 PyObject * obj1 = 0 ;
21642 char * kwnames[] = {
21643 (char *) "x",(char *) "y", NULL
21644 };
21645
21646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21647 if (obj0) {
21648 ecode1 = SWIG_AsVal_int(obj0, &val1);
21649 if (!SWIG_IsOK(ecode1)) {
21650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21651 }
21652 arg1 = static_cast< int >(val1);
21653 }
21654 if (obj1) {
21655 ecode2 = SWIG_AsVal_int(obj1, &val2);
21656 if (!SWIG_IsOK(ecode2)) {
21657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21658 }
21659 arg2 = static_cast< int >(val2);
21660 }
21661 {
21662 PyThreadState* __tstate = wxPyBeginAllowThreads();
21663 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21664 wxPyEndAllowThreads(__tstate);
21665 if (PyErr_Occurred()) SWIG_fail;
21666 }
21667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21668 return resultobj;
21669 fail:
21670 return NULL;
21671 }
21672
21673
21674 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21675 PyObject *resultobj = 0;
21676 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21677 int result;
21678 void *argp1 = 0 ;
21679 int res1 = 0 ;
21680 PyObject *swig_obj[1] ;
21681
21682 if (!args) SWIG_fail;
21683 swig_obj[0] = args;
21684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21685 if (!SWIG_IsOK(res1)) {
21686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21687 }
21688 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21689 {
21690 PyThreadState* __tstate = wxPyBeginAllowThreads();
21691 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21692 wxPyEndAllowThreads(__tstate);
21693 if (PyErr_Occurred()) SWIG_fail;
21694 }
21695 resultobj = SWIG_From_int(static_cast< int >(result));
21696 return resultobj;
21697 fail:
21698 return NULL;
21699 }
21700
21701
21702 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21703 PyObject *resultobj = 0;
21704 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21705 int result;
21706 void *argp1 = 0 ;
21707 int res1 = 0 ;
21708 PyObject *swig_obj[1] ;
21709
21710 if (!args) SWIG_fail;
21711 swig_obj[0] = args;
21712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21713 if (!SWIG_IsOK(res1)) {
21714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21715 }
21716 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21717 {
21718 PyThreadState* __tstate = wxPyBeginAllowThreads();
21719 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 resultobj = SWIG_From_int(static_cast< int >(result));
21724 return resultobj;
21725 fail:
21726 return NULL;
21727 }
21728
21729
21730 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21731 PyObject *resultobj = 0;
21732 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21733 wxCursor *arg2 = 0 ;
21734 void *argp1 = 0 ;
21735 int res1 = 0 ;
21736 void *argp2 = 0 ;
21737 int res2 = 0 ;
21738 PyObject * obj0 = 0 ;
21739 PyObject * obj1 = 0 ;
21740 char * kwnames[] = {
21741 (char *) "self",(char *) "cursor", NULL
21742 };
21743
21744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21746 if (!SWIG_IsOK(res1)) {
21747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21748 }
21749 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21750 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21751 if (!SWIG_IsOK(res2)) {
21752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21753 }
21754 if (!argp2) {
21755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21756 }
21757 arg2 = reinterpret_cast< wxCursor * >(argp2);
21758 {
21759 PyThreadState* __tstate = wxPyBeginAllowThreads();
21760 (arg1)->SetCursor((wxCursor const &)*arg2);
21761 wxPyEndAllowThreads(__tstate);
21762 if (PyErr_Occurred()) SWIG_fail;
21763 }
21764 resultobj = SWIG_Py_Void();
21765 return resultobj;
21766 fail:
21767 return NULL;
21768 }
21769
21770
21771 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21772 PyObject *resultobj = 0;
21773 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21774 wxCursor *result = 0 ;
21775 void *argp1 = 0 ;
21776 int res1 = 0 ;
21777 PyObject *swig_obj[1] ;
21778
21779 if (!args) SWIG_fail;
21780 swig_obj[0] = args;
21781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21782 if (!SWIG_IsOK(res1)) {
21783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21784 }
21785 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21786 {
21787 PyThreadState* __tstate = wxPyBeginAllowThreads();
21788 {
21789 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21790 result = (wxCursor *) &_result_ref;
21791 }
21792 wxPyEndAllowThreads(__tstate);
21793 if (PyErr_Occurred()) SWIG_fail;
21794 }
21795 {
21796 wxCursor* resultptr = new wxCursor(*result);
21797 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21798 }
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21806 PyObject *resultobj = 0;
21807 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21808 bool result;
21809 void *argp1 = 0 ;
21810 int res1 = 0 ;
21811 PyObject *swig_obj[1] ;
21812
21813 if (!args) SWIG_fail;
21814 swig_obj[0] = args;
21815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21816 if (!SWIG_IsOK(res1)) {
21817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21818 }
21819 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21820 {
21821 PyThreadState* __tstate = wxPyBeginAllowThreads();
21822 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21823 wxPyEndAllowThreads(__tstate);
21824 if (PyErr_Occurred()) SWIG_fail;
21825 }
21826 {
21827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21828 }
21829 return resultobj;
21830 fail:
21831 return NULL;
21832 }
21833
21834
21835 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21836 PyObject *obj;
21837 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21838 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21839 return SWIG_Py_Void();
21840 }
21841
21842 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21843 return SWIG_Python_InitShadowInstance(args);
21844 }
21845
21846 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21847 PyObject *resultobj = 0;
21848 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21849 wxKeyEvent *result = 0 ;
21850 int val1 ;
21851 int ecode1 = 0 ;
21852 PyObject * obj0 = 0 ;
21853 char * kwnames[] = {
21854 (char *) "eventType", NULL
21855 };
21856
21857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21858 if (obj0) {
21859 ecode1 = SWIG_AsVal_int(obj0, &val1);
21860 if (!SWIG_IsOK(ecode1)) {
21861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21862 }
21863 arg1 = static_cast< wxEventType >(val1);
21864 }
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21879 PyObject *resultobj = 0;
21880 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21881 int result;
21882 void *argp1 = 0 ;
21883 int res1 = 0 ;
21884 PyObject *swig_obj[1] ;
21885
21886 if (!args) SWIG_fail;
21887 swig_obj[0] = args;
21888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21889 if (!SWIG_IsOK(res1)) {
21890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21891 }
21892 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21893 {
21894 PyThreadState* __tstate = wxPyBeginAllowThreads();
21895 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21896 wxPyEndAllowThreads(__tstate);
21897 if (PyErr_Occurred()) SWIG_fail;
21898 }
21899 resultobj = SWIG_From_int(static_cast< int >(result));
21900 return resultobj;
21901 fail:
21902 return NULL;
21903 }
21904
21905
21906 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21907 PyObject *resultobj = 0;
21908 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21909 bool result;
21910 void *argp1 = 0 ;
21911 int res1 = 0 ;
21912 PyObject *swig_obj[1] ;
21913
21914 if (!args) SWIG_fail;
21915 swig_obj[0] = args;
21916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21917 if (!SWIG_IsOK(res1)) {
21918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21919 }
21920 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21921 {
21922 PyThreadState* __tstate = wxPyBeginAllowThreads();
21923 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21924 wxPyEndAllowThreads(__tstate);
21925 if (PyErr_Occurred()) SWIG_fail;
21926 }
21927 {
21928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21929 }
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21937 PyObject *resultobj = 0;
21938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21939 bool result;
21940 void *argp1 = 0 ;
21941 int res1 = 0 ;
21942 PyObject *swig_obj[1] ;
21943
21944 if (!args) SWIG_fail;
21945 swig_obj[0] = args;
21946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21947 if (!SWIG_IsOK(res1)) {
21948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21949 }
21950 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21951 {
21952 PyThreadState* __tstate = wxPyBeginAllowThreads();
21953 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21954 wxPyEndAllowThreads(__tstate);
21955 if (PyErr_Occurred()) SWIG_fail;
21956 }
21957 {
21958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21959 }
21960 return resultobj;
21961 fail:
21962 return NULL;
21963 }
21964
21965
21966 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21967 PyObject *resultobj = 0;
21968 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21969 bool result;
21970 void *argp1 = 0 ;
21971 int res1 = 0 ;
21972 PyObject *swig_obj[1] ;
21973
21974 if (!args) SWIG_fail;
21975 swig_obj[0] = args;
21976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21977 if (!SWIG_IsOK(res1)) {
21978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21979 }
21980 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21981 {
21982 PyThreadState* __tstate = wxPyBeginAllowThreads();
21983 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21984 wxPyEndAllowThreads(__tstate);
21985 if (PyErr_Occurred()) SWIG_fail;
21986 }
21987 {
21988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21989 }
21990 return resultobj;
21991 fail:
21992 return NULL;
21993 }
21994
21995
21996 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21997 PyObject *resultobj = 0;
21998 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21999 bool result;
22000 void *argp1 = 0 ;
22001 int res1 = 0 ;
22002 PyObject *swig_obj[1] ;
22003
22004 if (!args) SWIG_fail;
22005 swig_obj[0] = args;
22006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22007 if (!SWIG_IsOK(res1)) {
22008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22009 }
22010 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22011 {
22012 PyThreadState* __tstate = wxPyBeginAllowThreads();
22013 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22014 wxPyEndAllowThreads(__tstate);
22015 if (PyErr_Occurred()) SWIG_fail;
22016 }
22017 {
22018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22019 }
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22027 PyObject *resultobj = 0;
22028 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22029 bool result;
22030 void *argp1 = 0 ;
22031 int res1 = 0 ;
22032 PyObject *swig_obj[1] ;
22033
22034 if (!args) SWIG_fail;
22035 swig_obj[0] = args;
22036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22037 if (!SWIG_IsOK(res1)) {
22038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22039 }
22040 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22041 {
22042 PyThreadState* __tstate = wxPyBeginAllowThreads();
22043 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22044 wxPyEndAllowThreads(__tstate);
22045 if (PyErr_Occurred()) SWIG_fail;
22046 }
22047 {
22048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22049 }
22050 return resultobj;
22051 fail:
22052 return NULL;
22053 }
22054
22055
22056 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22057 PyObject *resultobj = 0;
22058 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22059 bool result;
22060 void *argp1 = 0 ;
22061 int res1 = 0 ;
22062 PyObject *swig_obj[1] ;
22063
22064 if (!args) SWIG_fail;
22065 swig_obj[0] = args;
22066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22067 if (!SWIG_IsOK(res1)) {
22068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22069 }
22070 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22071 {
22072 PyThreadState* __tstate = wxPyBeginAllowThreads();
22073 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22074 wxPyEndAllowThreads(__tstate);
22075 if (PyErr_Occurred()) SWIG_fail;
22076 }
22077 {
22078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22079 }
22080 return resultobj;
22081 fail:
22082 return NULL;
22083 }
22084
22085
22086 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22087 PyObject *resultobj = 0;
22088 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22089 int result;
22090 void *argp1 = 0 ;
22091 int res1 = 0 ;
22092 PyObject *swig_obj[1] ;
22093
22094 if (!args) SWIG_fail;
22095 swig_obj[0] = args;
22096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22097 if (!SWIG_IsOK(res1)) {
22098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22099 }
22100 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22101 {
22102 PyThreadState* __tstate = wxPyBeginAllowThreads();
22103 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22104 wxPyEndAllowThreads(__tstate);
22105 if (PyErr_Occurred()) SWIG_fail;
22106 }
22107 resultobj = SWIG_From_int(static_cast< int >(result));
22108 return resultobj;
22109 fail:
22110 return NULL;
22111 }
22112
22113
22114 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22115 PyObject *resultobj = 0;
22116 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22117 int result;
22118 void *argp1 = 0 ;
22119 int res1 = 0 ;
22120 PyObject *swig_obj[1] ;
22121
22122 if (!args) SWIG_fail;
22123 swig_obj[0] = args;
22124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22125 if (!SWIG_IsOK(res1)) {
22126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22127 }
22128 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22132 wxPyEndAllowThreads(__tstate);
22133 if (PyErr_Occurred()) SWIG_fail;
22134 }
22135 resultobj = SWIG_From_int(static_cast< int >(result));
22136 return resultobj;
22137 fail:
22138 return NULL;
22139 }
22140
22141
22142 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22143 PyObject *resultobj = 0;
22144 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22145 int arg2 ;
22146 void *argp1 = 0 ;
22147 int res1 = 0 ;
22148 int val2 ;
22149 int ecode2 = 0 ;
22150 PyObject * obj0 = 0 ;
22151 PyObject * obj1 = 0 ;
22152 char * kwnames[] = {
22153 (char *) "self",(char *) "uniChar", NULL
22154 };
22155
22156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22160 }
22161 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22162 ecode2 = SWIG_AsVal_int(obj1, &val2);
22163 if (!SWIG_IsOK(ecode2)) {
22164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22165 }
22166 arg2 = static_cast< int >(val2);
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22170 wxPyEndAllowThreads(__tstate);
22171 if (PyErr_Occurred()) SWIG_fail;
22172 }
22173 resultobj = SWIG_Py_Void();
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22181 PyObject *resultobj = 0;
22182 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22183 unsigned int result;
22184 void *argp1 = 0 ;
22185 int res1 = 0 ;
22186 PyObject *swig_obj[1] ;
22187
22188 if (!args) SWIG_fail;
22189 swig_obj[0] = args;
22190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22191 if (!SWIG_IsOK(res1)) {
22192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22193 }
22194 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22198 wxPyEndAllowThreads(__tstate);
22199 if (PyErr_Occurred()) SWIG_fail;
22200 }
22201 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22209 PyObject *resultobj = 0;
22210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22211 unsigned int result;
22212 void *argp1 = 0 ;
22213 int res1 = 0 ;
22214 PyObject *swig_obj[1] ;
22215
22216 if (!args) SWIG_fail;
22217 swig_obj[0] = args;
22218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22219 if (!SWIG_IsOK(res1)) {
22220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22221 }
22222 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22239 wxPoint result;
22240 void *argp1 = 0 ;
22241 int res1 = 0 ;
22242 PyObject *swig_obj[1] ;
22243
22244 if (!args) SWIG_fail;
22245 swig_obj[0] = args;
22246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22247 if (!SWIG_IsOK(res1)) {
22248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22249 }
22250 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22251 {
22252 PyThreadState* __tstate = wxPyBeginAllowThreads();
22253 result = (arg1)->GetPosition();
22254 wxPyEndAllowThreads(__tstate);
22255 if (PyErr_Occurred()) SWIG_fail;
22256 }
22257 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22258 return resultobj;
22259 fail:
22260 return NULL;
22261 }
22262
22263
22264 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22265 PyObject *resultobj = 0;
22266 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22267 long *arg2 = (long *) 0 ;
22268 long *arg3 = (long *) 0 ;
22269 void *argp1 = 0 ;
22270 int res1 = 0 ;
22271 long temp2 ;
22272 int res2 = SWIG_TMPOBJ ;
22273 long temp3 ;
22274 int res3 = SWIG_TMPOBJ ;
22275 PyObject *swig_obj[1] ;
22276
22277 arg2 = &temp2;
22278 arg3 = &temp3;
22279 if (!args) SWIG_fail;
22280 swig_obj[0] = args;
22281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22282 if (!SWIG_IsOK(res1)) {
22283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22284 }
22285 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22286 {
22287 PyThreadState* __tstate = wxPyBeginAllowThreads();
22288 (arg1)->GetPosition(arg2,arg3);
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 resultobj = SWIG_Py_Void();
22293 if (SWIG_IsTmpObj(res2)) {
22294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22295 } else {
22296 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22298 }
22299 if (SWIG_IsTmpObj(res3)) {
22300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22301 } else {
22302 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22304 }
22305 return resultobj;
22306 fail:
22307 return NULL;
22308 }
22309
22310
22311 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 PyObject *resultobj = 0;
22313 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22314 int result;
22315 void *argp1 = 0 ;
22316 int res1 = 0 ;
22317 PyObject *swig_obj[1] ;
22318
22319 if (!args) SWIG_fail;
22320 swig_obj[0] = args;
22321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22322 if (!SWIG_IsOK(res1)) {
22323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22324 }
22325 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22326 {
22327 PyThreadState* __tstate = wxPyBeginAllowThreads();
22328 result = (int)((wxKeyEvent const *)arg1)->GetX();
22329 wxPyEndAllowThreads(__tstate);
22330 if (PyErr_Occurred()) SWIG_fail;
22331 }
22332 resultobj = SWIG_From_int(static_cast< int >(result));
22333 return resultobj;
22334 fail:
22335 return NULL;
22336 }
22337
22338
22339 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22340 PyObject *resultobj = 0;
22341 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22342 int result;
22343 void *argp1 = 0 ;
22344 int res1 = 0 ;
22345 PyObject *swig_obj[1] ;
22346
22347 if (!args) SWIG_fail;
22348 swig_obj[0] = args;
22349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22350 if (!SWIG_IsOK(res1)) {
22351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22352 }
22353 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22354 {
22355 PyThreadState* __tstate = wxPyBeginAllowThreads();
22356 result = (int)((wxKeyEvent const *)arg1)->GetY();
22357 wxPyEndAllowThreads(__tstate);
22358 if (PyErr_Occurred()) SWIG_fail;
22359 }
22360 resultobj = SWIG_From_int(static_cast< int >(result));
22361 return resultobj;
22362 fail:
22363 return NULL;
22364 }
22365
22366
22367 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22368 PyObject *resultobj = 0;
22369 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22370 int arg2 ;
22371 void *argp1 = 0 ;
22372 int res1 = 0 ;
22373 int val2 ;
22374 int ecode2 = 0 ;
22375 PyObject *swig_obj[2] ;
22376
22377 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22379 if (!SWIG_IsOK(res1)) {
22380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22381 }
22382 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22383 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22384 if (!SWIG_IsOK(ecode2)) {
22385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22386 }
22387 arg2 = static_cast< int >(val2);
22388 if (arg1) (arg1)->m_x = arg2;
22389
22390 resultobj = SWIG_Py_Void();
22391 return resultobj;
22392 fail:
22393 return NULL;
22394 }
22395
22396
22397 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22398 PyObject *resultobj = 0;
22399 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22400 int result;
22401 void *argp1 = 0 ;
22402 int res1 = 0 ;
22403 PyObject *swig_obj[1] ;
22404
22405 if (!args) SWIG_fail;
22406 swig_obj[0] = args;
22407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22408 if (!SWIG_IsOK(res1)) {
22409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22410 }
22411 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22412 result = (int) ((arg1)->m_x);
22413 resultobj = SWIG_From_int(static_cast< int >(result));
22414 return resultobj;
22415 fail:
22416 return NULL;
22417 }
22418
22419
22420 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22421 PyObject *resultobj = 0;
22422 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22423 int arg2 ;
22424 void *argp1 = 0 ;
22425 int res1 = 0 ;
22426 int val2 ;
22427 int ecode2 = 0 ;
22428 PyObject *swig_obj[2] ;
22429
22430 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22432 if (!SWIG_IsOK(res1)) {
22433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22434 }
22435 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22436 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22437 if (!SWIG_IsOK(ecode2)) {
22438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22439 }
22440 arg2 = static_cast< int >(val2);
22441 if (arg1) (arg1)->m_y = arg2;
22442
22443 resultobj = SWIG_Py_Void();
22444 return resultobj;
22445 fail:
22446 return NULL;
22447 }
22448
22449
22450 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22451 PyObject *resultobj = 0;
22452 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22453 int result;
22454 void *argp1 = 0 ;
22455 int res1 = 0 ;
22456 PyObject *swig_obj[1] ;
22457
22458 if (!args) SWIG_fail;
22459 swig_obj[0] = args;
22460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22461 if (!SWIG_IsOK(res1)) {
22462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22463 }
22464 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22465 result = (int) ((arg1)->m_y);
22466 resultobj = SWIG_From_int(static_cast< int >(result));
22467 return resultobj;
22468 fail:
22469 return NULL;
22470 }
22471
22472
22473 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22474 PyObject *resultobj = 0;
22475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22476 long arg2 ;
22477 void *argp1 = 0 ;
22478 int res1 = 0 ;
22479 long val2 ;
22480 int ecode2 = 0 ;
22481 PyObject *swig_obj[2] ;
22482
22483 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22485 if (!SWIG_IsOK(res1)) {
22486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22487 }
22488 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22489 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22490 if (!SWIG_IsOK(ecode2)) {
22491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22492 }
22493 arg2 = static_cast< long >(val2);
22494 if (arg1) (arg1)->m_keyCode = arg2;
22495
22496 resultobj = SWIG_Py_Void();
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22504 PyObject *resultobj = 0;
22505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22506 long result;
22507 void *argp1 = 0 ;
22508 int res1 = 0 ;
22509 PyObject *swig_obj[1] ;
22510
22511 if (!args) SWIG_fail;
22512 swig_obj[0] = args;
22513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22514 if (!SWIG_IsOK(res1)) {
22515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22516 }
22517 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22518 result = (long) ((arg1)->m_keyCode);
22519 resultobj = SWIG_From_long(static_cast< long >(result));
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22527 PyObject *resultobj = 0;
22528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22529 bool arg2 ;
22530 void *argp1 = 0 ;
22531 int res1 = 0 ;
22532 bool val2 ;
22533 int ecode2 = 0 ;
22534 PyObject *swig_obj[2] ;
22535
22536 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22540 }
22541 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22542 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22543 if (!SWIG_IsOK(ecode2)) {
22544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22545 }
22546 arg2 = static_cast< bool >(val2);
22547 if (arg1) (arg1)->m_controlDown = arg2;
22548
22549 resultobj = SWIG_Py_Void();
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22557 PyObject *resultobj = 0;
22558 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22559 bool result;
22560 void *argp1 = 0 ;
22561 int res1 = 0 ;
22562 PyObject *swig_obj[1] ;
22563
22564 if (!args) SWIG_fail;
22565 swig_obj[0] = args;
22566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22567 if (!SWIG_IsOK(res1)) {
22568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22569 }
22570 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22571 result = (bool) ((arg1)->m_controlDown);
22572 {
22573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22574 }
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22582 PyObject *resultobj = 0;
22583 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22584 bool arg2 ;
22585 void *argp1 = 0 ;
22586 int res1 = 0 ;
22587 bool val2 ;
22588 int ecode2 = 0 ;
22589 PyObject *swig_obj[2] ;
22590
22591 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22593 if (!SWIG_IsOK(res1)) {
22594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22595 }
22596 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22597 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22598 if (!SWIG_IsOK(ecode2)) {
22599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22600 }
22601 arg2 = static_cast< bool >(val2);
22602 if (arg1) (arg1)->m_shiftDown = arg2;
22603
22604 resultobj = SWIG_Py_Void();
22605 return resultobj;
22606 fail:
22607 return NULL;
22608 }
22609
22610
22611 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22612 PyObject *resultobj = 0;
22613 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22614 bool result;
22615 void *argp1 = 0 ;
22616 int res1 = 0 ;
22617 PyObject *swig_obj[1] ;
22618
22619 if (!args) SWIG_fail;
22620 swig_obj[0] = args;
22621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22622 if (!SWIG_IsOK(res1)) {
22623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22624 }
22625 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22626 result = (bool) ((arg1)->m_shiftDown);
22627 {
22628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22629 }
22630 return resultobj;
22631 fail:
22632 return NULL;
22633 }
22634
22635
22636 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22637 PyObject *resultobj = 0;
22638 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22639 bool arg2 ;
22640 void *argp1 = 0 ;
22641 int res1 = 0 ;
22642 bool val2 ;
22643 int ecode2 = 0 ;
22644 PyObject *swig_obj[2] ;
22645
22646 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22648 if (!SWIG_IsOK(res1)) {
22649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22650 }
22651 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22652 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22653 if (!SWIG_IsOK(ecode2)) {
22654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22655 }
22656 arg2 = static_cast< bool >(val2);
22657 if (arg1) (arg1)->m_altDown = arg2;
22658
22659 resultobj = SWIG_Py_Void();
22660 return resultobj;
22661 fail:
22662 return NULL;
22663 }
22664
22665
22666 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22667 PyObject *resultobj = 0;
22668 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22669 bool result;
22670 void *argp1 = 0 ;
22671 int res1 = 0 ;
22672 PyObject *swig_obj[1] ;
22673
22674 if (!args) SWIG_fail;
22675 swig_obj[0] = args;
22676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22677 if (!SWIG_IsOK(res1)) {
22678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22679 }
22680 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22681 result = (bool) ((arg1)->m_altDown);
22682 {
22683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22684 }
22685 return resultobj;
22686 fail:
22687 return NULL;
22688 }
22689
22690
22691 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22692 PyObject *resultobj = 0;
22693 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22694 bool arg2 ;
22695 void *argp1 = 0 ;
22696 int res1 = 0 ;
22697 bool val2 ;
22698 int ecode2 = 0 ;
22699 PyObject *swig_obj[2] ;
22700
22701 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22705 }
22706 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22707 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22708 if (!SWIG_IsOK(ecode2)) {
22709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22710 }
22711 arg2 = static_cast< bool >(val2);
22712 if (arg1) (arg1)->m_metaDown = arg2;
22713
22714 resultobj = SWIG_Py_Void();
22715 return resultobj;
22716 fail:
22717 return NULL;
22718 }
22719
22720
22721 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22722 PyObject *resultobj = 0;
22723 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22724 bool result;
22725 void *argp1 = 0 ;
22726 int res1 = 0 ;
22727 PyObject *swig_obj[1] ;
22728
22729 if (!args) SWIG_fail;
22730 swig_obj[0] = args;
22731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22732 if (!SWIG_IsOK(res1)) {
22733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22734 }
22735 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22736 result = (bool) ((arg1)->m_metaDown);
22737 {
22738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22739 }
22740 return resultobj;
22741 fail:
22742 return NULL;
22743 }
22744
22745
22746 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22747 PyObject *resultobj = 0;
22748 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22749 bool arg2 ;
22750 void *argp1 = 0 ;
22751 int res1 = 0 ;
22752 bool val2 ;
22753 int ecode2 = 0 ;
22754 PyObject *swig_obj[2] ;
22755
22756 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22758 if (!SWIG_IsOK(res1)) {
22759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22760 }
22761 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22762 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22763 if (!SWIG_IsOK(ecode2)) {
22764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22765 }
22766 arg2 = static_cast< bool >(val2);
22767 if (arg1) (arg1)->m_scanCode = arg2;
22768
22769 resultobj = SWIG_Py_Void();
22770 return resultobj;
22771 fail:
22772 return NULL;
22773 }
22774
22775
22776 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22777 PyObject *resultobj = 0;
22778 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22779 bool result;
22780 void *argp1 = 0 ;
22781 int res1 = 0 ;
22782 PyObject *swig_obj[1] ;
22783
22784 if (!args) SWIG_fail;
22785 swig_obj[0] = args;
22786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22787 if (!SWIG_IsOK(res1)) {
22788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22789 }
22790 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22791 result = (bool) ((arg1)->m_scanCode);
22792 {
22793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22794 }
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802 PyObject *resultobj = 0;
22803 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22804 unsigned int arg2 ;
22805 void *argp1 = 0 ;
22806 int res1 = 0 ;
22807 unsigned int val2 ;
22808 int ecode2 = 0 ;
22809 PyObject *swig_obj[2] ;
22810
22811 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22813 if (!SWIG_IsOK(res1)) {
22814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22815 }
22816 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22817 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22818 if (!SWIG_IsOK(ecode2)) {
22819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22820 }
22821 arg2 = static_cast< unsigned int >(val2);
22822 if (arg1) (arg1)->m_rawCode = arg2;
22823
22824 resultobj = SWIG_Py_Void();
22825 return resultobj;
22826 fail:
22827 return NULL;
22828 }
22829
22830
22831 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22832 PyObject *resultobj = 0;
22833 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22834 unsigned int result;
22835 void *argp1 = 0 ;
22836 int res1 = 0 ;
22837 PyObject *swig_obj[1] ;
22838
22839 if (!args) SWIG_fail;
22840 swig_obj[0] = args;
22841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22842 if (!SWIG_IsOK(res1)) {
22843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22844 }
22845 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22846 result = (unsigned int) ((arg1)->m_rawCode);
22847 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22848 return resultobj;
22849 fail:
22850 return NULL;
22851 }
22852
22853
22854 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22855 PyObject *resultobj = 0;
22856 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22857 unsigned int arg2 ;
22858 void *argp1 = 0 ;
22859 int res1 = 0 ;
22860 unsigned int val2 ;
22861 int ecode2 = 0 ;
22862 PyObject *swig_obj[2] ;
22863
22864 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22866 if (!SWIG_IsOK(res1)) {
22867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22868 }
22869 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22870 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22871 if (!SWIG_IsOK(ecode2)) {
22872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22873 }
22874 arg2 = static_cast< unsigned int >(val2);
22875 if (arg1) (arg1)->m_rawFlags = arg2;
22876
22877 resultobj = SWIG_Py_Void();
22878 return resultobj;
22879 fail:
22880 return NULL;
22881 }
22882
22883
22884 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22885 PyObject *resultobj = 0;
22886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22887 unsigned int result;
22888 void *argp1 = 0 ;
22889 int res1 = 0 ;
22890 PyObject *swig_obj[1] ;
22891
22892 if (!args) SWIG_fail;
22893 swig_obj[0] = args;
22894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22895 if (!SWIG_IsOK(res1)) {
22896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22897 }
22898 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22899 result = (unsigned int) ((arg1)->m_rawFlags);
22900 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22908 PyObject *obj;
22909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22910 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22911 return SWIG_Py_Void();
22912 }
22913
22914 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22915 return SWIG_Python_InitShadowInstance(args);
22916 }
22917
22918 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22919 PyObject *resultobj = 0;
22920 wxSize const &arg1_defvalue = wxDefaultSize ;
22921 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22922 int arg2 = (int) 0 ;
22923 wxSizeEvent *result = 0 ;
22924 wxSize temp1 ;
22925 int val2 ;
22926 int ecode2 = 0 ;
22927 PyObject * obj0 = 0 ;
22928 PyObject * obj1 = 0 ;
22929 char * kwnames[] = {
22930 (char *) "sz",(char *) "winid", NULL
22931 };
22932
22933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22934 if (obj0) {
22935 {
22936 arg1 = &temp1;
22937 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22938 }
22939 }
22940 if (obj1) {
22941 ecode2 = SWIG_AsVal_int(obj1, &val2);
22942 if (!SWIG_IsOK(ecode2)) {
22943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22944 }
22945 arg2 = static_cast< int >(val2);
22946 }
22947 {
22948 PyThreadState* __tstate = wxPyBeginAllowThreads();
22949 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22961 PyObject *resultobj = 0;
22962 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22963 wxSize result;
22964 void *argp1 = 0 ;
22965 int res1 = 0 ;
22966 PyObject *swig_obj[1] ;
22967
22968 if (!args) SWIG_fail;
22969 swig_obj[0] = args;
22970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22971 if (!SWIG_IsOK(res1)) {
22972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22973 }
22974 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 result = ((wxSizeEvent const *)arg1)->GetSize();
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22989 PyObject *resultobj = 0;
22990 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22991 wxRect result;
22992 void *argp1 = 0 ;
22993 int res1 = 0 ;
22994 PyObject *swig_obj[1] ;
22995
22996 if (!args) SWIG_fail;
22997 swig_obj[0] = args;
22998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22999 if (!SWIG_IsOK(res1)) {
23000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23001 }
23002 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23003 {
23004 PyThreadState* __tstate = wxPyBeginAllowThreads();
23005 result = ((wxSizeEvent const *)arg1)->GetRect();
23006 wxPyEndAllowThreads(__tstate);
23007 if (PyErr_Occurred()) SWIG_fail;
23008 }
23009 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23017 PyObject *resultobj = 0;
23018 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23019 wxRect arg2 ;
23020 void *argp1 = 0 ;
23021 int res1 = 0 ;
23022 void *argp2 ;
23023 int res2 = 0 ;
23024 PyObject * obj0 = 0 ;
23025 PyObject * obj1 = 0 ;
23026 char * kwnames[] = {
23027 (char *) "self",(char *) "rect", NULL
23028 };
23029
23030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23032 if (!SWIG_IsOK(res1)) {
23033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23034 }
23035 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23036 {
23037 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23038 if (!SWIG_IsOK(res2)) {
23039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23040 }
23041 if (!argp2) {
23042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23043 } else {
23044 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23045 arg2 = *temp;
23046 if (SWIG_IsNewObj(res2)) delete temp;
23047 }
23048 }
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 (arg1)->SetRect(arg2);
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 resultobj = SWIG_Py_Void();
23056 return resultobj;
23057 fail:
23058 return NULL;
23059 }
23060
23061
23062 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23063 PyObject *resultobj = 0;
23064 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23065 wxSize arg2 ;
23066 void *argp1 = 0 ;
23067 int res1 = 0 ;
23068 void *argp2 ;
23069 int res2 = 0 ;
23070 PyObject * obj0 = 0 ;
23071 PyObject * obj1 = 0 ;
23072 char * kwnames[] = {
23073 (char *) "self",(char *) "size", NULL
23074 };
23075
23076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23078 if (!SWIG_IsOK(res1)) {
23079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23080 }
23081 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23082 {
23083 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23084 if (!SWIG_IsOK(res2)) {
23085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23086 }
23087 if (!argp2) {
23088 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23089 } else {
23090 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23091 arg2 = *temp;
23092 if (SWIG_IsNewObj(res2)) delete temp;
23093 }
23094 }
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 wxSizeEvent_SetSize(arg1,arg2);
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 resultobj = SWIG_Py_Void();
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 PyObject *resultobj = 0;
23110 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23111 wxSize *arg2 = (wxSize *) 0 ;
23112 void *argp1 = 0 ;
23113 int res1 = 0 ;
23114 void *argp2 = 0 ;
23115 int res2 = 0 ;
23116 PyObject *swig_obj[2] ;
23117
23118 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23120 if (!SWIG_IsOK(res1)) {
23121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23122 }
23123 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23124 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23125 if (!SWIG_IsOK(res2)) {
23126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23127 }
23128 arg2 = reinterpret_cast< wxSize * >(argp2);
23129 if (arg1) (arg1)->m_size = *arg2;
23130
23131 resultobj = SWIG_Py_Void();
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23139 PyObject *resultobj = 0;
23140 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23141 wxSize *result = 0 ;
23142 void *argp1 = 0 ;
23143 int res1 = 0 ;
23144 PyObject *swig_obj[1] ;
23145
23146 if (!args) SWIG_fail;
23147 swig_obj[0] = args;
23148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23149 if (!SWIG_IsOK(res1)) {
23150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23151 }
23152 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23153 result = (wxSize *)& ((arg1)->m_size);
23154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23155 return resultobj;
23156 fail:
23157 return NULL;
23158 }
23159
23160
23161 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23162 PyObject *resultobj = 0;
23163 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23164 wxRect *arg2 = (wxRect *) 0 ;
23165 void *argp1 = 0 ;
23166 int res1 = 0 ;
23167 void *argp2 = 0 ;
23168 int res2 = 0 ;
23169 PyObject *swig_obj[2] ;
23170
23171 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23173 if (!SWIG_IsOK(res1)) {
23174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23175 }
23176 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23177 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23178 if (!SWIG_IsOK(res2)) {
23179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23180 }
23181 arg2 = reinterpret_cast< wxRect * >(argp2);
23182 if (arg1) (arg1)->m_rect = *arg2;
23183
23184 resultobj = SWIG_Py_Void();
23185 return resultobj;
23186 fail:
23187 return NULL;
23188 }
23189
23190
23191 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23192 PyObject *resultobj = 0;
23193 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23194 wxRect *result = 0 ;
23195 void *argp1 = 0 ;
23196 int res1 = 0 ;
23197 PyObject *swig_obj[1] ;
23198
23199 if (!args) SWIG_fail;
23200 swig_obj[0] = args;
23201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23202 if (!SWIG_IsOK(res1)) {
23203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23204 }
23205 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23206 result = (wxRect *)& ((arg1)->m_rect);
23207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23215 PyObject *obj;
23216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23217 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23218 return SWIG_Py_Void();
23219 }
23220
23221 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23222 return SWIG_Python_InitShadowInstance(args);
23223 }
23224
23225 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23226 PyObject *resultobj = 0;
23227 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23228 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23229 int arg2 = (int) 0 ;
23230 wxMoveEvent *result = 0 ;
23231 wxPoint temp1 ;
23232 int val2 ;
23233 int ecode2 = 0 ;
23234 PyObject * obj0 = 0 ;
23235 PyObject * obj1 = 0 ;
23236 char * kwnames[] = {
23237 (char *) "pos",(char *) "winid", NULL
23238 };
23239
23240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23241 if (obj0) {
23242 {
23243 arg1 = &temp1;
23244 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23245 }
23246 }
23247 if (obj1) {
23248 ecode2 = SWIG_AsVal_int(obj1, &val2);
23249 if (!SWIG_IsOK(ecode2)) {
23250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23251 }
23252 arg2 = static_cast< int >(val2);
23253 }
23254 {
23255 PyThreadState* __tstate = wxPyBeginAllowThreads();
23256 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23257 wxPyEndAllowThreads(__tstate);
23258 if (PyErr_Occurred()) SWIG_fail;
23259 }
23260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23268 PyObject *resultobj = 0;
23269 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23270 wxPoint result;
23271 void *argp1 = 0 ;
23272 int res1 = 0 ;
23273 PyObject *swig_obj[1] ;
23274
23275 if (!args) SWIG_fail;
23276 swig_obj[0] = args;
23277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23278 if (!SWIG_IsOK(res1)) {
23279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23280 }
23281 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 result = ((wxMoveEvent const *)arg1)->GetPosition();
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23289 return resultobj;
23290 fail:
23291 return NULL;
23292 }
23293
23294
23295 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23296 PyObject *resultobj = 0;
23297 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23298 wxRect result;
23299 void *argp1 = 0 ;
23300 int res1 = 0 ;
23301 PyObject *swig_obj[1] ;
23302
23303 if (!args) SWIG_fail;
23304 swig_obj[0] = args;
23305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23306 if (!SWIG_IsOK(res1)) {
23307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23308 }
23309 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23310 {
23311 PyThreadState* __tstate = wxPyBeginAllowThreads();
23312 result = ((wxMoveEvent const *)arg1)->GetRect();
23313 wxPyEndAllowThreads(__tstate);
23314 if (PyErr_Occurred()) SWIG_fail;
23315 }
23316 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23317 return resultobj;
23318 fail:
23319 return NULL;
23320 }
23321
23322
23323 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23324 PyObject *resultobj = 0;
23325 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23326 wxRect *arg2 = 0 ;
23327 void *argp1 = 0 ;
23328 int res1 = 0 ;
23329 wxRect temp2 ;
23330 PyObject * obj0 = 0 ;
23331 PyObject * obj1 = 0 ;
23332 char * kwnames[] = {
23333 (char *) "self",(char *) "rect", NULL
23334 };
23335
23336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23338 if (!SWIG_IsOK(res1)) {
23339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23340 }
23341 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23342 {
23343 arg2 = &temp2;
23344 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23345 }
23346 {
23347 PyThreadState* __tstate = wxPyBeginAllowThreads();
23348 (arg1)->SetRect((wxRect const &)*arg2);
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 resultobj = SWIG_Py_Void();
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj = 0;
23361 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23362 wxPoint *arg2 = 0 ;
23363 void *argp1 = 0 ;
23364 int res1 = 0 ;
23365 wxPoint temp2 ;
23366 PyObject * obj0 = 0 ;
23367 PyObject * obj1 = 0 ;
23368 char * kwnames[] = {
23369 (char *) "self",(char *) "pos", NULL
23370 };
23371
23372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23374 if (!SWIG_IsOK(res1)) {
23375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23376 }
23377 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23378 {
23379 arg2 = &temp2;
23380 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23381 }
23382 {
23383 PyThreadState* __tstate = wxPyBeginAllowThreads();
23384 (arg1)->SetPosition((wxPoint const &)*arg2);
23385 wxPyEndAllowThreads(__tstate);
23386 if (PyErr_Occurred()) SWIG_fail;
23387 }
23388 resultobj = SWIG_Py_Void();
23389 return resultobj;
23390 fail:
23391 return NULL;
23392 }
23393
23394
23395 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23396 PyObject *obj;
23397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23398 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23399 return SWIG_Py_Void();
23400 }
23401
23402 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23403 return SWIG_Python_InitShadowInstance(args);
23404 }
23405
23406 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj = 0;
23408 int arg1 = (int) 0 ;
23409 wxPaintEvent *result = 0 ;
23410 int val1 ;
23411 int ecode1 = 0 ;
23412 PyObject * obj0 = 0 ;
23413 char * kwnames[] = {
23414 (char *) "Id", NULL
23415 };
23416
23417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23418 if (obj0) {
23419 ecode1 = SWIG_AsVal_int(obj0, &val1);
23420 if (!SWIG_IsOK(ecode1)) {
23421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23422 }
23423 arg1 = static_cast< int >(val1);
23424 }
23425 {
23426 PyThreadState* __tstate = wxPyBeginAllowThreads();
23427 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23428 wxPyEndAllowThreads(__tstate);
23429 if (PyErr_Occurred()) SWIG_fail;
23430 }
23431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23432 return resultobj;
23433 fail:
23434 return NULL;
23435 }
23436
23437
23438 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23439 PyObject *obj;
23440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23441 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23442 return SWIG_Py_Void();
23443 }
23444
23445 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23446 return SWIG_Python_InitShadowInstance(args);
23447 }
23448
23449 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23450 PyObject *resultobj = 0;
23451 int arg1 = (int) 0 ;
23452 wxNcPaintEvent *result = 0 ;
23453 int val1 ;
23454 int ecode1 = 0 ;
23455 PyObject * obj0 = 0 ;
23456 char * kwnames[] = {
23457 (char *) "winid", NULL
23458 };
23459
23460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23461 if (obj0) {
23462 ecode1 = SWIG_AsVal_int(obj0, &val1);
23463 if (!SWIG_IsOK(ecode1)) {
23464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23465 }
23466 arg1 = static_cast< int >(val1);
23467 }
23468 {
23469 PyThreadState* __tstate = wxPyBeginAllowThreads();
23470 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23471 wxPyEndAllowThreads(__tstate);
23472 if (PyErr_Occurred()) SWIG_fail;
23473 }
23474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23475 return resultobj;
23476 fail:
23477 return NULL;
23478 }
23479
23480
23481 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23482 PyObject *obj;
23483 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23484 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23485 return SWIG_Py_Void();
23486 }
23487
23488 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23489 return SWIG_Python_InitShadowInstance(args);
23490 }
23491
23492 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23493 PyObject *resultobj = 0;
23494 int arg1 = (int) 0 ;
23495 wxDC *arg2 = (wxDC *) NULL ;
23496 wxEraseEvent *result = 0 ;
23497 int val1 ;
23498 int ecode1 = 0 ;
23499 void *argp2 = 0 ;
23500 int res2 = 0 ;
23501 PyObject * obj0 = 0 ;
23502 PyObject * obj1 = 0 ;
23503 char * kwnames[] = {
23504 (char *) "Id",(char *) "dc", NULL
23505 };
23506
23507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23508 if (obj0) {
23509 ecode1 = SWIG_AsVal_int(obj0, &val1);
23510 if (!SWIG_IsOK(ecode1)) {
23511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23512 }
23513 arg1 = static_cast< int >(val1);
23514 }
23515 if (obj1) {
23516 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23517 if (!SWIG_IsOK(res2)) {
23518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23519 }
23520 arg2 = reinterpret_cast< wxDC * >(argp2);
23521 }
23522 {
23523 PyThreadState* __tstate = wxPyBeginAllowThreads();
23524 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23525 wxPyEndAllowThreads(__tstate);
23526 if (PyErr_Occurred()) SWIG_fail;
23527 }
23528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23536 PyObject *resultobj = 0;
23537 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23538 wxDC *result = 0 ;
23539 void *argp1 = 0 ;
23540 int res1 = 0 ;
23541 PyObject *swig_obj[1] ;
23542
23543 if (!args) SWIG_fail;
23544 swig_obj[0] = args;
23545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23546 if (!SWIG_IsOK(res1)) {
23547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23548 }
23549 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23553 wxPyEndAllowThreads(__tstate);
23554 if (PyErr_Occurred()) SWIG_fail;
23555 }
23556 {
23557 resultobj = wxPyMake_wxObject(result, (bool)0);
23558 }
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23566 PyObject *obj;
23567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23568 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23569 return SWIG_Py_Void();
23570 }
23571
23572 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23573 return SWIG_Python_InitShadowInstance(args);
23574 }
23575
23576 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj = 0;
23578 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23579 int arg2 = (int) 0 ;
23580 wxFocusEvent *result = 0 ;
23581 int val1 ;
23582 int ecode1 = 0 ;
23583 int val2 ;
23584 int ecode2 = 0 ;
23585 PyObject * obj0 = 0 ;
23586 PyObject * obj1 = 0 ;
23587 char * kwnames[] = {
23588 (char *) "type",(char *) "winid", NULL
23589 };
23590
23591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23592 if (obj0) {
23593 ecode1 = SWIG_AsVal_int(obj0, &val1);
23594 if (!SWIG_IsOK(ecode1)) {
23595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23596 }
23597 arg1 = static_cast< wxEventType >(val1);
23598 }
23599 if (obj1) {
23600 ecode2 = SWIG_AsVal_int(obj1, &val2);
23601 if (!SWIG_IsOK(ecode2)) {
23602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23603 }
23604 arg2 = static_cast< int >(val2);
23605 }
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23620 PyObject *resultobj = 0;
23621 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23622 wxWindow *result = 0 ;
23623 void *argp1 = 0 ;
23624 int res1 = 0 ;
23625 PyObject *swig_obj[1] ;
23626
23627 if (!args) SWIG_fail;
23628 swig_obj[0] = args;
23629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23630 if (!SWIG_IsOK(res1)) {
23631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23632 }
23633 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23634 {
23635 PyThreadState* __tstate = wxPyBeginAllowThreads();
23636 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23637 wxPyEndAllowThreads(__tstate);
23638 if (PyErr_Occurred()) SWIG_fail;
23639 }
23640 {
23641 resultobj = wxPyMake_wxObject(result, (bool)0);
23642 }
23643 return resultobj;
23644 fail:
23645 return NULL;
23646 }
23647
23648
23649 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj = 0;
23651 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23652 wxWindow *arg2 = (wxWindow *) 0 ;
23653 void *argp1 = 0 ;
23654 int res1 = 0 ;
23655 void *argp2 = 0 ;
23656 int res2 = 0 ;
23657 PyObject * obj0 = 0 ;
23658 PyObject * obj1 = 0 ;
23659 char * kwnames[] = {
23660 (char *) "self",(char *) "win", NULL
23661 };
23662
23663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23665 if (!SWIG_IsOK(res1)) {
23666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23667 }
23668 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23669 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23670 if (!SWIG_IsOK(res2)) {
23671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23672 }
23673 arg2 = reinterpret_cast< wxWindow * >(argp2);
23674 {
23675 PyThreadState* __tstate = wxPyBeginAllowThreads();
23676 (arg1)->SetWindow(arg2);
23677 wxPyEndAllowThreads(__tstate);
23678 if (PyErr_Occurred()) SWIG_fail;
23679 }
23680 resultobj = SWIG_Py_Void();
23681 return resultobj;
23682 fail:
23683 return NULL;
23684 }
23685
23686
23687 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23688 PyObject *obj;
23689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23690 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23691 return SWIG_Py_Void();
23692 }
23693
23694 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23695 return SWIG_Python_InitShadowInstance(args);
23696 }
23697
23698 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23699 PyObject *resultobj = 0;
23700 wxWindow *arg1 = (wxWindow *) NULL ;
23701 wxChildFocusEvent *result = 0 ;
23702 void *argp1 = 0 ;
23703 int res1 = 0 ;
23704 PyObject * obj0 = 0 ;
23705 char * kwnames[] = {
23706 (char *) "win", NULL
23707 };
23708
23709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23710 if (obj0) {
23711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23712 if (!SWIG_IsOK(res1)) {
23713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23714 }
23715 arg1 = reinterpret_cast< wxWindow * >(argp1);
23716 }
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23720 wxPyEndAllowThreads(__tstate);
23721 if (PyErr_Occurred()) SWIG_fail;
23722 }
23723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23724 return resultobj;
23725 fail:
23726 return NULL;
23727 }
23728
23729
23730 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23731 PyObject *resultobj = 0;
23732 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23733 wxWindow *result = 0 ;
23734 void *argp1 = 0 ;
23735 int res1 = 0 ;
23736 PyObject *swig_obj[1] ;
23737
23738 if (!args) SWIG_fail;
23739 swig_obj[0] = args;
23740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23741 if (!SWIG_IsOK(res1)) {
23742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23743 }
23744 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23745 {
23746 PyThreadState* __tstate = wxPyBeginAllowThreads();
23747 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23748 wxPyEndAllowThreads(__tstate);
23749 if (PyErr_Occurred()) SWIG_fail;
23750 }
23751 {
23752 resultobj = wxPyMake_wxObject(result, (bool)0);
23753 }
23754 return resultobj;
23755 fail:
23756 return NULL;
23757 }
23758
23759
23760 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23761 PyObject *obj;
23762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23763 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23764 return SWIG_Py_Void();
23765 }
23766
23767 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23768 return SWIG_Python_InitShadowInstance(args);
23769 }
23770
23771 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23772 PyObject *resultobj = 0;
23773 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23774 bool arg2 = (bool) true ;
23775 int arg3 = (int) 0 ;
23776 wxActivateEvent *result = 0 ;
23777 int val1 ;
23778 int ecode1 = 0 ;
23779 bool val2 ;
23780 int ecode2 = 0 ;
23781 int val3 ;
23782 int ecode3 = 0 ;
23783 PyObject * obj0 = 0 ;
23784 PyObject * obj1 = 0 ;
23785 PyObject * obj2 = 0 ;
23786 char * kwnames[] = {
23787 (char *) "type",(char *) "active",(char *) "Id", NULL
23788 };
23789
23790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23791 if (obj0) {
23792 ecode1 = SWIG_AsVal_int(obj0, &val1);
23793 if (!SWIG_IsOK(ecode1)) {
23794 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23795 }
23796 arg1 = static_cast< wxEventType >(val1);
23797 }
23798 if (obj1) {
23799 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23800 if (!SWIG_IsOK(ecode2)) {
23801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23802 }
23803 arg2 = static_cast< bool >(val2);
23804 }
23805 if (obj2) {
23806 ecode3 = SWIG_AsVal_int(obj2, &val3);
23807 if (!SWIG_IsOK(ecode3)) {
23808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23809 }
23810 arg3 = static_cast< int >(val3);
23811 }
23812 {
23813 PyThreadState* __tstate = wxPyBeginAllowThreads();
23814 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23815 wxPyEndAllowThreads(__tstate);
23816 if (PyErr_Occurred()) SWIG_fail;
23817 }
23818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 PyObject *resultobj = 0;
23827 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23828 bool result;
23829 void *argp1 = 0 ;
23830 int res1 = 0 ;
23831 PyObject *swig_obj[1] ;
23832
23833 if (!args) SWIG_fail;
23834 swig_obj[0] = args;
23835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23836 if (!SWIG_IsOK(res1)) {
23837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23838 }
23839 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 {
23847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23848 }
23849 return resultobj;
23850 fail:
23851 return NULL;
23852 }
23853
23854
23855 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23856 PyObject *obj;
23857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23858 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23859 return SWIG_Py_Void();
23860 }
23861
23862 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23863 return SWIG_Python_InitShadowInstance(args);
23864 }
23865
23866 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23867 PyObject *resultobj = 0;
23868 int arg1 = (int) 0 ;
23869 wxInitDialogEvent *result = 0 ;
23870 int val1 ;
23871 int ecode1 = 0 ;
23872 PyObject * obj0 = 0 ;
23873 char * kwnames[] = {
23874 (char *) "Id", NULL
23875 };
23876
23877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23878 if (obj0) {
23879 ecode1 = SWIG_AsVal_int(obj0, &val1);
23880 if (!SWIG_IsOK(ecode1)) {
23881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23882 }
23883 arg1 = static_cast< int >(val1);
23884 }
23885 {
23886 PyThreadState* __tstate = wxPyBeginAllowThreads();
23887 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23888 wxPyEndAllowThreads(__tstate);
23889 if (PyErr_Occurred()) SWIG_fail;
23890 }
23891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23892 return resultobj;
23893 fail:
23894 return NULL;
23895 }
23896
23897
23898 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23899 PyObject *obj;
23900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23901 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23902 return SWIG_Py_Void();
23903 }
23904
23905 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23906 return SWIG_Python_InitShadowInstance(args);
23907 }
23908
23909 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23910 PyObject *resultobj = 0;
23911 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23912 int arg2 = (int) 0 ;
23913 wxMenu *arg3 = (wxMenu *) NULL ;
23914 wxMenuEvent *result = 0 ;
23915 int val1 ;
23916 int ecode1 = 0 ;
23917 int val2 ;
23918 int ecode2 = 0 ;
23919 void *argp3 = 0 ;
23920 int res3 = 0 ;
23921 PyObject * obj0 = 0 ;
23922 PyObject * obj1 = 0 ;
23923 PyObject * obj2 = 0 ;
23924 char * kwnames[] = {
23925 (char *) "type",(char *) "winid",(char *) "menu", NULL
23926 };
23927
23928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23929 if (obj0) {
23930 ecode1 = SWIG_AsVal_int(obj0, &val1);
23931 if (!SWIG_IsOK(ecode1)) {
23932 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23933 }
23934 arg1 = static_cast< wxEventType >(val1);
23935 }
23936 if (obj1) {
23937 ecode2 = SWIG_AsVal_int(obj1, &val2);
23938 if (!SWIG_IsOK(ecode2)) {
23939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23940 }
23941 arg2 = static_cast< int >(val2);
23942 }
23943 if (obj2) {
23944 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23945 if (!SWIG_IsOK(res3)) {
23946 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23947 }
23948 arg3 = reinterpret_cast< wxMenu * >(argp3);
23949 }
23950 {
23951 PyThreadState* __tstate = wxPyBeginAllowThreads();
23952 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23953 wxPyEndAllowThreads(__tstate);
23954 if (PyErr_Occurred()) SWIG_fail;
23955 }
23956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23964 PyObject *resultobj = 0;
23965 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23966 int result;
23967 void *argp1 = 0 ;
23968 int res1 = 0 ;
23969 PyObject *swig_obj[1] ;
23970
23971 if (!args) SWIG_fail;
23972 swig_obj[0] = args;
23973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23974 if (!SWIG_IsOK(res1)) {
23975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23976 }
23977 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23978 {
23979 PyThreadState* __tstate = wxPyBeginAllowThreads();
23980 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23981 wxPyEndAllowThreads(__tstate);
23982 if (PyErr_Occurred()) SWIG_fail;
23983 }
23984 resultobj = SWIG_From_int(static_cast< int >(result));
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23994 bool result;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 PyObject *swig_obj[1] ;
23998
23999 if (!args) SWIG_fail;
24000 swig_obj[0] = args;
24001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24002 if (!SWIG_IsOK(res1)) {
24003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24004 }
24005 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 {
24013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24014 }
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24024 wxMenu *result = 0 ;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 PyObject *swig_obj[1] ;
24028
24029 if (!args) SWIG_fail;
24030 swig_obj[0] = args;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24034 }
24035 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 {
24043 resultobj = wxPyMake_wxObject(result, (bool)0);
24044 }
24045 return resultobj;
24046 fail:
24047 return NULL;
24048 }
24049
24050
24051 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24052 PyObject *obj;
24053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24054 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24055 return SWIG_Py_Void();
24056 }
24057
24058 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24059 return SWIG_Python_InitShadowInstance(args);
24060 }
24061
24062 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24063 PyObject *resultobj = 0;
24064 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24065 int arg2 = (int) 0 ;
24066 wxCloseEvent *result = 0 ;
24067 int val1 ;
24068 int ecode1 = 0 ;
24069 int val2 ;
24070 int ecode2 = 0 ;
24071 PyObject * obj0 = 0 ;
24072 PyObject * obj1 = 0 ;
24073 char * kwnames[] = {
24074 (char *) "type",(char *) "winid", NULL
24075 };
24076
24077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24078 if (obj0) {
24079 ecode1 = SWIG_AsVal_int(obj0, &val1);
24080 if (!SWIG_IsOK(ecode1)) {
24081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24082 }
24083 arg1 = static_cast< wxEventType >(val1);
24084 }
24085 if (obj1) {
24086 ecode2 = SWIG_AsVal_int(obj1, &val2);
24087 if (!SWIG_IsOK(ecode2)) {
24088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24089 }
24090 arg2 = static_cast< int >(val2);
24091 }
24092 {
24093 PyThreadState* __tstate = wxPyBeginAllowThreads();
24094 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24095 wxPyEndAllowThreads(__tstate);
24096 if (PyErr_Occurred()) SWIG_fail;
24097 }
24098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24106 PyObject *resultobj = 0;
24107 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24108 bool arg2 ;
24109 void *argp1 = 0 ;
24110 int res1 = 0 ;
24111 bool val2 ;
24112 int ecode2 = 0 ;
24113 PyObject * obj0 = 0 ;
24114 PyObject * obj1 = 0 ;
24115 char * kwnames[] = {
24116 (char *) "self",(char *) "logOff", NULL
24117 };
24118
24119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24121 if (!SWIG_IsOK(res1)) {
24122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24123 }
24124 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24125 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24126 if (!SWIG_IsOK(ecode2)) {
24127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24128 }
24129 arg2 = static_cast< bool >(val2);
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 (arg1)->SetLoggingOff(arg2);
24133 wxPyEndAllowThreads(__tstate);
24134 if (PyErr_Occurred()) SWIG_fail;
24135 }
24136 resultobj = SWIG_Py_Void();
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24144 PyObject *resultobj = 0;
24145 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24146 bool result;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 PyObject *swig_obj[1] ;
24150
24151 if (!args) SWIG_fail;
24152 swig_obj[0] = args;
24153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24154 if (!SWIG_IsOK(res1)) {
24155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24156 }
24157 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 {
24165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24166 }
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24174 PyObject *resultobj = 0;
24175 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24176 bool arg2 = (bool) true ;
24177 void *argp1 = 0 ;
24178 int res1 = 0 ;
24179 bool val2 ;
24180 int ecode2 = 0 ;
24181 PyObject * obj0 = 0 ;
24182 PyObject * obj1 = 0 ;
24183 char * kwnames[] = {
24184 (char *) "self",(char *) "veto", NULL
24185 };
24186
24187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24189 if (!SWIG_IsOK(res1)) {
24190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24191 }
24192 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24193 if (obj1) {
24194 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24195 if (!SWIG_IsOK(ecode2)) {
24196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24197 }
24198 arg2 = static_cast< bool >(val2);
24199 }
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 (arg1)->Veto(arg2);
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 resultobj = SWIG_Py_Void();
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24214 PyObject *resultobj = 0;
24215 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24216 bool result;
24217 void *argp1 = 0 ;
24218 int res1 = 0 ;
24219 PyObject *swig_obj[1] ;
24220
24221 if (!args) SWIG_fail;
24222 swig_obj[0] = args;
24223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24224 if (!SWIG_IsOK(res1)) {
24225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24226 }
24227 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24228 {
24229 PyThreadState* __tstate = wxPyBeginAllowThreads();
24230 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24231 wxPyEndAllowThreads(__tstate);
24232 if (PyErr_Occurred()) SWIG_fail;
24233 }
24234 {
24235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24236 }
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24244 PyObject *resultobj = 0;
24245 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24246 bool arg2 ;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 bool val2 ;
24250 int ecode2 = 0 ;
24251 PyObject * obj0 = 0 ;
24252 PyObject * obj1 = 0 ;
24253 char * kwnames[] = {
24254 (char *) "self",(char *) "canVeto", NULL
24255 };
24256
24257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24259 if (!SWIG_IsOK(res1)) {
24260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24261 }
24262 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24264 if (!SWIG_IsOK(ecode2)) {
24265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24266 }
24267 arg2 = static_cast< bool >(val2);
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 (arg1)->SetCanVeto(arg2);
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 resultobj = SWIG_Py_Void();
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *resultobj = 0;
24283 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24284 bool result;
24285 void *argp1 = 0 ;
24286 int res1 = 0 ;
24287 PyObject *swig_obj[1] ;
24288
24289 if (!args) SWIG_fail;
24290 swig_obj[0] = args;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24294 }
24295 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 {
24303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24304 }
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24312 PyObject *obj;
24313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24314 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24315 return SWIG_Py_Void();
24316 }
24317
24318 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24319 return SWIG_Python_InitShadowInstance(args);
24320 }
24321
24322 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24323 PyObject *resultobj = 0;
24324 int arg1 = (int) 0 ;
24325 bool arg2 = (bool) false ;
24326 wxShowEvent *result = 0 ;
24327 int val1 ;
24328 int ecode1 = 0 ;
24329 bool val2 ;
24330 int ecode2 = 0 ;
24331 PyObject * obj0 = 0 ;
24332 PyObject * obj1 = 0 ;
24333 char * kwnames[] = {
24334 (char *) "winid",(char *) "show", NULL
24335 };
24336
24337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24338 if (obj0) {
24339 ecode1 = SWIG_AsVal_int(obj0, &val1);
24340 if (!SWIG_IsOK(ecode1)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24342 }
24343 arg1 = static_cast< int >(val1);
24344 }
24345 if (obj1) {
24346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24347 if (!SWIG_IsOK(ecode2)) {
24348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24349 }
24350 arg2 = static_cast< bool >(val2);
24351 }
24352 {
24353 PyThreadState* __tstate = wxPyBeginAllowThreads();
24354 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24355 wxPyEndAllowThreads(__tstate);
24356 if (PyErr_Occurred()) SWIG_fail;
24357 }
24358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24366 PyObject *resultobj = 0;
24367 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24368 bool arg2 ;
24369 void *argp1 = 0 ;
24370 int res1 = 0 ;
24371 bool val2 ;
24372 int ecode2 = 0 ;
24373 PyObject * obj0 = 0 ;
24374 PyObject * obj1 = 0 ;
24375 char * kwnames[] = {
24376 (char *) "self",(char *) "show", NULL
24377 };
24378
24379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24381 if (!SWIG_IsOK(res1)) {
24382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24383 }
24384 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24385 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24386 if (!SWIG_IsOK(ecode2)) {
24387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24388 }
24389 arg2 = static_cast< bool >(val2);
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 (arg1)->SetShow(arg2);
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 resultobj = SWIG_Py_Void();
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24404 PyObject *resultobj = 0;
24405 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24406 bool result;
24407 void *argp1 = 0 ;
24408 int res1 = 0 ;
24409 PyObject *swig_obj[1] ;
24410
24411 if (!args) SWIG_fail;
24412 swig_obj[0] = args;
24413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24414 if (!SWIG_IsOK(res1)) {
24415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24416 }
24417 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24421 wxPyEndAllowThreads(__tstate);
24422 if (PyErr_Occurred()) SWIG_fail;
24423 }
24424 {
24425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24426 }
24427 return resultobj;
24428 fail:
24429 return NULL;
24430 }
24431
24432
24433 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24434 PyObject *obj;
24435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24436 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24437 return SWIG_Py_Void();
24438 }
24439
24440 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24441 return SWIG_Python_InitShadowInstance(args);
24442 }
24443
24444 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24445 PyObject *resultobj = 0;
24446 int arg1 = (int) 0 ;
24447 bool arg2 = (bool) true ;
24448 wxIconizeEvent *result = 0 ;
24449 int val1 ;
24450 int ecode1 = 0 ;
24451 bool val2 ;
24452 int ecode2 = 0 ;
24453 PyObject * obj0 = 0 ;
24454 PyObject * obj1 = 0 ;
24455 char * kwnames[] = {
24456 (char *) "id",(char *) "iconized", NULL
24457 };
24458
24459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24460 if (obj0) {
24461 ecode1 = SWIG_AsVal_int(obj0, &val1);
24462 if (!SWIG_IsOK(ecode1)) {
24463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24464 }
24465 arg1 = static_cast< int >(val1);
24466 }
24467 if (obj1) {
24468 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24469 if (!SWIG_IsOK(ecode2)) {
24470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24471 }
24472 arg2 = static_cast< bool >(val2);
24473 }
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24477 wxPyEndAllowThreads(__tstate);
24478 if (PyErr_Occurred()) SWIG_fail;
24479 }
24480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24488 PyObject *resultobj = 0;
24489 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24490 bool result;
24491 void *argp1 = 0 ;
24492 int res1 = 0 ;
24493 PyObject *swig_obj[1] ;
24494
24495 if (!args) SWIG_fail;
24496 swig_obj[0] = args;
24497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24498 if (!SWIG_IsOK(res1)) {
24499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24500 }
24501 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24502 {
24503 PyThreadState* __tstate = wxPyBeginAllowThreads();
24504 result = (bool)(arg1)->Iconized();
24505 wxPyEndAllowThreads(__tstate);
24506 if (PyErr_Occurred()) SWIG_fail;
24507 }
24508 {
24509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24510 }
24511 return resultobj;
24512 fail:
24513 return NULL;
24514 }
24515
24516
24517 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24518 PyObject *obj;
24519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24520 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24521 return SWIG_Py_Void();
24522 }
24523
24524 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 return SWIG_Python_InitShadowInstance(args);
24526 }
24527
24528 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24529 PyObject *resultobj = 0;
24530 int arg1 = (int) 0 ;
24531 wxMaximizeEvent *result = 0 ;
24532 int val1 ;
24533 int ecode1 = 0 ;
24534 PyObject * obj0 = 0 ;
24535 char * kwnames[] = {
24536 (char *) "id", NULL
24537 };
24538
24539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24540 if (obj0) {
24541 ecode1 = SWIG_AsVal_int(obj0, &val1);
24542 if (!SWIG_IsOK(ecode1)) {
24543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24544 }
24545 arg1 = static_cast< int >(val1);
24546 }
24547 {
24548 PyThreadState* __tstate = wxPyBeginAllowThreads();
24549 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24561 PyObject *obj;
24562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24563 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24564 return SWIG_Py_Void();
24565 }
24566
24567 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24568 return SWIG_Python_InitShadowInstance(args);
24569 }
24570
24571 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24572 PyObject *resultobj = 0;
24573 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24574 wxPoint result;
24575 void *argp1 = 0 ;
24576 int res1 = 0 ;
24577 PyObject *swig_obj[1] ;
24578
24579 if (!args) SWIG_fail;
24580 swig_obj[0] = args;
24581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24582 if (!SWIG_IsOK(res1)) {
24583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24584 }
24585 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 result = (arg1)->GetPosition();
24589 wxPyEndAllowThreads(__tstate);
24590 if (PyErr_Occurred()) SWIG_fail;
24591 }
24592 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24593 return resultobj;
24594 fail:
24595 return NULL;
24596 }
24597
24598
24599 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 PyObject *resultobj = 0;
24601 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24602 int result;
24603 void *argp1 = 0 ;
24604 int res1 = 0 ;
24605 PyObject *swig_obj[1] ;
24606
24607 if (!args) SWIG_fail;
24608 swig_obj[0] = args;
24609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24610 if (!SWIG_IsOK(res1)) {
24611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24612 }
24613 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 result = (int)(arg1)->GetNumberOfFiles();
24617 wxPyEndAllowThreads(__tstate);
24618 if (PyErr_Occurred()) SWIG_fail;
24619 }
24620 resultobj = SWIG_From_int(static_cast< int >(result));
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24628 PyObject *resultobj = 0;
24629 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24630 PyObject *result = 0 ;
24631 void *argp1 = 0 ;
24632 int res1 = 0 ;
24633 PyObject *swig_obj[1] ;
24634
24635 if (!args) SWIG_fail;
24636 swig_obj[0] = args;
24637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24638 if (!SWIG_IsOK(res1)) {
24639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24640 }
24641 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24642 {
24643 PyThreadState* __tstate = wxPyBeginAllowThreads();
24644 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24645 wxPyEndAllowThreads(__tstate);
24646 if (PyErr_Occurred()) SWIG_fail;
24647 }
24648 resultobj = result;
24649 return resultobj;
24650 fail:
24651 return NULL;
24652 }
24653
24654
24655 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24656 PyObject *obj;
24657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24658 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24659 return SWIG_Py_Void();
24660 }
24661
24662 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj = 0;
24664 int arg1 = (int) 0 ;
24665 wxUpdateUIEvent *result = 0 ;
24666 int val1 ;
24667 int ecode1 = 0 ;
24668 PyObject * obj0 = 0 ;
24669 char * kwnames[] = {
24670 (char *) "commandId", NULL
24671 };
24672
24673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24674 if (obj0) {
24675 ecode1 = SWIG_AsVal_int(obj0, &val1);
24676 if (!SWIG_IsOK(ecode1)) {
24677 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24678 }
24679 arg1 = static_cast< int >(val1);
24680 }
24681 {
24682 PyThreadState* __tstate = wxPyBeginAllowThreads();
24683 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24684 wxPyEndAllowThreads(__tstate);
24685 if (PyErr_Occurred()) SWIG_fail;
24686 }
24687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24695 PyObject *resultobj = 0;
24696 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24697 bool result;
24698 void *argp1 = 0 ;
24699 int res1 = 0 ;
24700 PyObject *swig_obj[1] ;
24701
24702 if (!args) SWIG_fail;
24703 swig_obj[0] = args;
24704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24705 if (!SWIG_IsOK(res1)) {
24706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24707 }
24708 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 {
24716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24725 PyObject *resultobj = 0;
24726 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24727 bool result;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 PyObject *swig_obj[1] ;
24731
24732 if (!args) SWIG_fail;
24733 swig_obj[0] = args;
24734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24737 }
24738 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 {
24746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24747 }
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24755 PyObject *resultobj = 0;
24756 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24757 bool result;
24758 void *argp1 = 0 ;
24759 int res1 = 0 ;
24760 PyObject *swig_obj[1] ;
24761
24762 if (!args) SWIG_fail;
24763 swig_obj[0] = args;
24764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24767 }
24768 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
24771 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24772 wxPyEndAllowThreads(__tstate);
24773 if (PyErr_Occurred()) SWIG_fail;
24774 }
24775 {
24776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24777 }
24778 return resultobj;
24779 fail:
24780 return NULL;
24781 }
24782
24783
24784 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24785 PyObject *resultobj = 0;
24786 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24787 wxString result;
24788 void *argp1 = 0 ;
24789 int res1 = 0 ;
24790 PyObject *swig_obj[1] ;
24791
24792 if (!args) SWIG_fail;
24793 swig_obj[0] = args;
24794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24795 if (!SWIG_IsOK(res1)) {
24796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24797 }
24798 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 {
24806 #if wxUSE_UNICODE
24807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24808 #else
24809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24810 #endif
24811 }
24812 return resultobj;
24813 fail:
24814 return NULL;
24815 }
24816
24817
24818 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24819 PyObject *resultobj = 0;
24820 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24821 bool result;
24822 void *argp1 = 0 ;
24823 int res1 = 0 ;
24824 PyObject *swig_obj[1] ;
24825
24826 if (!args) SWIG_fail;
24827 swig_obj[0] = args;
24828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24829 if (!SWIG_IsOK(res1)) {
24830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24831 }
24832 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24833 {
24834 PyThreadState* __tstate = wxPyBeginAllowThreads();
24835 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 {
24840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24841 }
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24849 PyObject *resultobj = 0;
24850 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24851 bool result;
24852 void *argp1 = 0 ;
24853 int res1 = 0 ;
24854 PyObject *swig_obj[1] ;
24855
24856 if (!args) SWIG_fail;
24857 swig_obj[0] = args;
24858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24859 if (!SWIG_IsOK(res1)) {
24860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24861 }
24862 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24866 wxPyEndAllowThreads(__tstate);
24867 if (PyErr_Occurred()) SWIG_fail;
24868 }
24869 {
24870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24871 }
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24879 PyObject *resultobj = 0;
24880 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24881 bool result;
24882 void *argp1 = 0 ;
24883 int res1 = 0 ;
24884 PyObject *swig_obj[1] ;
24885
24886 if (!args) SWIG_fail;
24887 swig_obj[0] = args;
24888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24889 if (!SWIG_IsOK(res1)) {
24890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24891 }
24892 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24893 {
24894 PyThreadState* __tstate = wxPyBeginAllowThreads();
24895 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24896 wxPyEndAllowThreads(__tstate);
24897 if (PyErr_Occurred()) SWIG_fail;
24898 }
24899 {
24900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24901 }
24902 return resultobj;
24903 fail:
24904 return NULL;
24905 }
24906
24907
24908 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24909 PyObject *resultobj = 0;
24910 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24911 bool result;
24912 void *argp1 = 0 ;
24913 int res1 = 0 ;
24914 PyObject *swig_obj[1] ;
24915
24916 if (!args) SWIG_fail;
24917 swig_obj[0] = args;
24918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24919 if (!SWIG_IsOK(res1)) {
24920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24921 }
24922 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24923 {
24924 PyThreadState* __tstate = wxPyBeginAllowThreads();
24925 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24926 wxPyEndAllowThreads(__tstate);
24927 if (PyErr_Occurred()) SWIG_fail;
24928 }
24929 {
24930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24931 }
24932 return resultobj;
24933 fail:
24934 return NULL;
24935 }
24936
24937
24938 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24939 PyObject *resultobj = 0;
24940 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24941 bool arg2 ;
24942 void *argp1 = 0 ;
24943 int res1 = 0 ;
24944 bool val2 ;
24945 int ecode2 = 0 ;
24946 PyObject * obj0 = 0 ;
24947 PyObject * obj1 = 0 ;
24948 char * kwnames[] = {
24949 (char *) "self",(char *) "check", NULL
24950 };
24951
24952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24954 if (!SWIG_IsOK(res1)) {
24955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24956 }
24957 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24958 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24959 if (!SWIG_IsOK(ecode2)) {
24960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24961 }
24962 arg2 = static_cast< bool >(val2);
24963 {
24964 PyThreadState* __tstate = wxPyBeginAllowThreads();
24965 (arg1)->Check(arg2);
24966 wxPyEndAllowThreads(__tstate);
24967 if (PyErr_Occurred()) SWIG_fail;
24968 }
24969 resultobj = SWIG_Py_Void();
24970 return resultobj;
24971 fail:
24972 return NULL;
24973 }
24974
24975
24976 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24977 PyObject *resultobj = 0;
24978 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24979 bool arg2 ;
24980 void *argp1 = 0 ;
24981 int res1 = 0 ;
24982 bool val2 ;
24983 int ecode2 = 0 ;
24984 PyObject * obj0 = 0 ;
24985 PyObject * obj1 = 0 ;
24986 char * kwnames[] = {
24987 (char *) "self",(char *) "enable", NULL
24988 };
24989
24990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24992 if (!SWIG_IsOK(res1)) {
24993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24994 }
24995 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24996 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24997 if (!SWIG_IsOK(ecode2)) {
24998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24999 }
25000 arg2 = static_cast< bool >(val2);
25001 {
25002 PyThreadState* __tstate = wxPyBeginAllowThreads();
25003 (arg1)->Enable(arg2);
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 resultobj = SWIG_Py_Void();
25008 return resultobj;
25009 fail:
25010 return NULL;
25011 }
25012
25013
25014 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25015 PyObject *resultobj = 0;
25016 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25017 bool arg2 ;
25018 void *argp1 = 0 ;
25019 int res1 = 0 ;
25020 bool val2 ;
25021 int ecode2 = 0 ;
25022 PyObject * obj0 = 0 ;
25023 PyObject * obj1 = 0 ;
25024 char * kwnames[] = {
25025 (char *) "self",(char *) "show", NULL
25026 };
25027
25028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25030 if (!SWIG_IsOK(res1)) {
25031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25032 }
25033 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25034 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25035 if (!SWIG_IsOK(ecode2)) {
25036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25037 }
25038 arg2 = static_cast< bool >(val2);
25039 {
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 (arg1)->Show(arg2);
25042 wxPyEndAllowThreads(__tstate);
25043 if (PyErr_Occurred()) SWIG_fail;
25044 }
25045 resultobj = SWIG_Py_Void();
25046 return resultobj;
25047 fail:
25048 return NULL;
25049 }
25050
25051
25052 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25053 PyObject *resultobj = 0;
25054 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25055 wxString *arg2 = 0 ;
25056 void *argp1 = 0 ;
25057 int res1 = 0 ;
25058 bool temp2 = false ;
25059 PyObject * obj0 = 0 ;
25060 PyObject * obj1 = 0 ;
25061 char * kwnames[] = {
25062 (char *) "self",(char *) "text", NULL
25063 };
25064
25065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25067 if (!SWIG_IsOK(res1)) {
25068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25069 }
25070 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25071 {
25072 arg2 = wxString_in_helper(obj1);
25073 if (arg2 == NULL) SWIG_fail;
25074 temp2 = true;
25075 }
25076 {
25077 PyThreadState* __tstate = wxPyBeginAllowThreads();
25078 (arg1)->SetText((wxString const &)*arg2);
25079 wxPyEndAllowThreads(__tstate);
25080 if (PyErr_Occurred()) SWIG_fail;
25081 }
25082 resultobj = SWIG_Py_Void();
25083 {
25084 if (temp2)
25085 delete arg2;
25086 }
25087 return resultobj;
25088 fail:
25089 {
25090 if (temp2)
25091 delete arg2;
25092 }
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj = 0;
25099 long arg1 ;
25100 long val1 ;
25101 int ecode1 = 0 ;
25102 PyObject * obj0 = 0 ;
25103 char * kwnames[] = {
25104 (char *) "updateInterval", NULL
25105 };
25106
25107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25108 ecode1 = SWIG_AsVal_long(obj0, &val1);
25109 if (!SWIG_IsOK(ecode1)) {
25110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25111 }
25112 arg1 = static_cast< long >(val1);
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 wxUpdateUIEvent::SetUpdateInterval(arg1);
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 resultobj = SWIG_Py_Void();
25120 return resultobj;
25121 fail:
25122 return NULL;
25123 }
25124
25125
25126 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25127 PyObject *resultobj = 0;
25128 long result;
25129
25130 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25131 {
25132 PyThreadState* __tstate = wxPyBeginAllowThreads();
25133 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 resultobj = SWIG_From_long(static_cast< long >(result));
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25145 PyObject *resultobj = 0;
25146 wxWindow *arg1 = (wxWindow *) 0 ;
25147 bool result;
25148 void *argp1 = 0 ;
25149 int res1 = 0 ;
25150 PyObject * obj0 = 0 ;
25151 char * kwnames[] = {
25152 (char *) "win", NULL
25153 };
25154
25155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25157 if (!SWIG_IsOK(res1)) {
25158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25159 }
25160 arg1 = reinterpret_cast< wxWindow * >(argp1);
25161 {
25162 PyThreadState* __tstate = wxPyBeginAllowThreads();
25163 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25164 wxPyEndAllowThreads(__tstate);
25165 if (PyErr_Occurred()) SWIG_fail;
25166 }
25167 {
25168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25169 }
25170 return resultobj;
25171 fail:
25172 return NULL;
25173 }
25174
25175
25176 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25177 PyObject *resultobj = 0;
25178
25179 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 wxUpdateUIEvent::ResetUpdateTime();
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 resultobj = SWIG_Py_Void();
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25194 PyObject *resultobj = 0;
25195 wxUpdateUIMode arg1 ;
25196 int val1 ;
25197 int ecode1 = 0 ;
25198 PyObject * obj0 = 0 ;
25199 char * kwnames[] = {
25200 (char *) "mode", NULL
25201 };
25202
25203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25204 ecode1 = SWIG_AsVal_int(obj0, &val1);
25205 if (!SWIG_IsOK(ecode1)) {
25206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25207 }
25208 arg1 = static_cast< wxUpdateUIMode >(val1);
25209 {
25210 PyThreadState* __tstate = wxPyBeginAllowThreads();
25211 wxUpdateUIEvent::SetMode(arg1);
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 resultobj = SWIG_Py_Void();
25216 return resultobj;
25217 fail:
25218 return NULL;
25219 }
25220
25221
25222 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25223 PyObject *resultobj = 0;
25224 wxUpdateUIMode result;
25225
25226 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25227 {
25228 PyThreadState* __tstate = wxPyBeginAllowThreads();
25229 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25230 wxPyEndAllowThreads(__tstate);
25231 if (PyErr_Occurred()) SWIG_fail;
25232 }
25233 resultobj = SWIG_From_int(static_cast< int >(result));
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25241 PyObject *obj;
25242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25243 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25244 return SWIG_Py_Void();
25245 }
25246
25247 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 return SWIG_Python_InitShadowInstance(args);
25249 }
25250
25251 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25252 PyObject *resultobj = 0;
25253 wxSysColourChangedEvent *result = 0 ;
25254
25255 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25256 {
25257 PyThreadState* __tstate = wxPyBeginAllowThreads();
25258 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25259 wxPyEndAllowThreads(__tstate);
25260 if (PyErr_Occurred()) SWIG_fail;
25261 }
25262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25263 return resultobj;
25264 fail:
25265 return NULL;
25266 }
25267
25268
25269 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25270 PyObject *obj;
25271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25272 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25273 return SWIG_Py_Void();
25274 }
25275
25276 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25277 return SWIG_Python_InitShadowInstance(args);
25278 }
25279
25280 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj = 0;
25282 int arg1 = (int) 0 ;
25283 wxWindow *arg2 = (wxWindow *) NULL ;
25284 wxMouseCaptureChangedEvent *result = 0 ;
25285 int val1 ;
25286 int ecode1 = 0 ;
25287 void *argp2 = 0 ;
25288 int res2 = 0 ;
25289 PyObject * obj0 = 0 ;
25290 PyObject * obj1 = 0 ;
25291 char * kwnames[] = {
25292 (char *) "winid",(char *) "gainedCapture", NULL
25293 };
25294
25295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25296 if (obj0) {
25297 ecode1 = SWIG_AsVal_int(obj0, &val1);
25298 if (!SWIG_IsOK(ecode1)) {
25299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25300 }
25301 arg1 = static_cast< int >(val1);
25302 }
25303 if (obj1) {
25304 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25305 if (!SWIG_IsOK(res2)) {
25306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25307 }
25308 arg2 = reinterpret_cast< wxWindow * >(argp2);
25309 }
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25324 PyObject *resultobj = 0;
25325 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25326 wxWindow *result = 0 ;
25327 void *argp1 = 0 ;
25328 int res1 = 0 ;
25329 PyObject *swig_obj[1] ;
25330
25331 if (!args) SWIG_fail;
25332 swig_obj[0] = args;
25333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25334 if (!SWIG_IsOK(res1)) {
25335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25336 }
25337 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25338 {
25339 PyThreadState* __tstate = wxPyBeginAllowThreads();
25340 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25341 wxPyEndAllowThreads(__tstate);
25342 if (PyErr_Occurred()) SWIG_fail;
25343 }
25344 {
25345 resultobj = wxPyMake_wxObject(result, (bool)0);
25346 }
25347 return resultobj;
25348 fail:
25349 return NULL;
25350 }
25351
25352
25353 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25354 PyObject *obj;
25355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25356 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25357 return SWIG_Py_Void();
25358 }
25359
25360 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25361 return SWIG_Python_InitShadowInstance(args);
25362 }
25363
25364 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25365 PyObject *resultobj = 0;
25366 wxDisplayChangedEvent *result = 0 ;
25367
25368 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25372 wxPyEndAllowThreads(__tstate);
25373 if (PyErr_Occurred()) SWIG_fail;
25374 }
25375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25376 return resultobj;
25377 fail:
25378 return NULL;
25379 }
25380
25381
25382 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25383 PyObject *obj;
25384 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25385 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25386 return SWIG_Py_Void();
25387 }
25388
25389 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25390 return SWIG_Python_InitShadowInstance(args);
25391 }
25392
25393 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25394 PyObject *resultobj = 0;
25395 int arg1 = (int) 0 ;
25396 wxPaletteChangedEvent *result = 0 ;
25397 int val1 ;
25398 int ecode1 = 0 ;
25399 PyObject * obj0 = 0 ;
25400 char * kwnames[] = {
25401 (char *) "id", NULL
25402 };
25403
25404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25405 if (obj0) {
25406 ecode1 = SWIG_AsVal_int(obj0, &val1);
25407 if (!SWIG_IsOK(ecode1)) {
25408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25409 }
25410 arg1 = static_cast< int >(val1);
25411 }
25412 {
25413 PyThreadState* __tstate = wxPyBeginAllowThreads();
25414 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25415 wxPyEndAllowThreads(__tstate);
25416 if (PyErr_Occurred()) SWIG_fail;
25417 }
25418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25419 return resultobj;
25420 fail:
25421 return NULL;
25422 }
25423
25424
25425 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25426 PyObject *resultobj = 0;
25427 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25428 wxWindow *arg2 = (wxWindow *) 0 ;
25429 void *argp1 = 0 ;
25430 int res1 = 0 ;
25431 void *argp2 = 0 ;
25432 int res2 = 0 ;
25433 PyObject * obj0 = 0 ;
25434 PyObject * obj1 = 0 ;
25435 char * kwnames[] = {
25436 (char *) "self",(char *) "win", NULL
25437 };
25438
25439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25441 if (!SWIG_IsOK(res1)) {
25442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25443 }
25444 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25445 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25446 if (!SWIG_IsOK(res2)) {
25447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25448 }
25449 arg2 = reinterpret_cast< wxWindow * >(argp2);
25450 {
25451 PyThreadState* __tstate = wxPyBeginAllowThreads();
25452 (arg1)->SetChangedWindow(arg2);
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 resultobj = SWIG_Py_Void();
25457 return resultobj;
25458 fail:
25459 return NULL;
25460 }
25461
25462
25463 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25464 PyObject *resultobj = 0;
25465 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25466 wxWindow *result = 0 ;
25467 void *argp1 = 0 ;
25468 int res1 = 0 ;
25469 PyObject *swig_obj[1] ;
25470
25471 if (!args) SWIG_fail;
25472 swig_obj[0] = args;
25473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25474 if (!SWIG_IsOK(res1)) {
25475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25476 }
25477 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25478 {
25479 PyThreadState* __tstate = wxPyBeginAllowThreads();
25480 result = (wxWindow *)(arg1)->GetChangedWindow();
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 {
25485 resultobj = wxPyMake_wxObject(result, (bool)0);
25486 }
25487 return resultobj;
25488 fail:
25489 return NULL;
25490 }
25491
25492
25493 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25494 PyObject *obj;
25495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25496 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25497 return SWIG_Py_Void();
25498 }
25499
25500 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25501 return SWIG_Python_InitShadowInstance(args);
25502 }
25503
25504 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25505 PyObject *resultobj = 0;
25506 int arg1 = (int) 0 ;
25507 wxQueryNewPaletteEvent *result = 0 ;
25508 int val1 ;
25509 int ecode1 = 0 ;
25510 PyObject * obj0 = 0 ;
25511 char * kwnames[] = {
25512 (char *) "winid", NULL
25513 };
25514
25515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25516 if (obj0) {
25517 ecode1 = SWIG_AsVal_int(obj0, &val1);
25518 if (!SWIG_IsOK(ecode1)) {
25519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25520 }
25521 arg1 = static_cast< int >(val1);
25522 }
25523 {
25524 PyThreadState* __tstate = wxPyBeginAllowThreads();
25525 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25526 wxPyEndAllowThreads(__tstate);
25527 if (PyErr_Occurred()) SWIG_fail;
25528 }
25529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25530 return resultobj;
25531 fail:
25532 return NULL;
25533 }
25534
25535
25536 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25537 PyObject *resultobj = 0;
25538 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25539 bool arg2 ;
25540 void *argp1 = 0 ;
25541 int res1 = 0 ;
25542 bool val2 ;
25543 int ecode2 = 0 ;
25544 PyObject * obj0 = 0 ;
25545 PyObject * obj1 = 0 ;
25546 char * kwnames[] = {
25547 (char *) "self",(char *) "realized", NULL
25548 };
25549
25550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25552 if (!SWIG_IsOK(res1)) {
25553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25554 }
25555 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25556 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25557 if (!SWIG_IsOK(ecode2)) {
25558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25559 }
25560 arg2 = static_cast< bool >(val2);
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 (arg1)->SetPaletteRealized(arg2);
25564 wxPyEndAllowThreads(__tstate);
25565 if (PyErr_Occurred()) SWIG_fail;
25566 }
25567 resultobj = SWIG_Py_Void();
25568 return resultobj;
25569 fail:
25570 return NULL;
25571 }
25572
25573
25574 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25575 PyObject *resultobj = 0;
25576 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25577 bool result;
25578 void *argp1 = 0 ;
25579 int res1 = 0 ;
25580 PyObject *swig_obj[1] ;
25581
25582 if (!args) SWIG_fail;
25583 swig_obj[0] = args;
25584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25585 if (!SWIG_IsOK(res1)) {
25586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25587 }
25588 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25589 {
25590 PyThreadState* __tstate = wxPyBeginAllowThreads();
25591 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25592 wxPyEndAllowThreads(__tstate);
25593 if (PyErr_Occurred()) SWIG_fail;
25594 }
25595 {
25596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25597 }
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25605 PyObject *obj;
25606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25607 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25608 return SWIG_Py_Void();
25609 }
25610
25611 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25612 return SWIG_Python_InitShadowInstance(args);
25613 }
25614
25615 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25616 PyObject *resultobj = 0;
25617 wxNavigationKeyEvent *result = 0 ;
25618
25619 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25620 {
25621 PyThreadState* __tstate = wxPyBeginAllowThreads();
25622 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25623 wxPyEndAllowThreads(__tstate);
25624 if (PyErr_Occurred()) SWIG_fail;
25625 }
25626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25634 PyObject *resultobj = 0;
25635 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25636 bool result;
25637 void *argp1 = 0 ;
25638 int res1 = 0 ;
25639 PyObject *swig_obj[1] ;
25640
25641 if (!args) SWIG_fail;
25642 swig_obj[0] = args;
25643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25644 if (!SWIG_IsOK(res1)) {
25645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25646 }
25647 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25648 {
25649 PyThreadState* __tstate = wxPyBeginAllowThreads();
25650 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25651 wxPyEndAllowThreads(__tstate);
25652 if (PyErr_Occurred()) SWIG_fail;
25653 }
25654 {
25655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25656 }
25657 return resultobj;
25658 fail:
25659 return NULL;
25660 }
25661
25662
25663 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25664 PyObject *resultobj = 0;
25665 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25666 bool arg2 ;
25667 void *argp1 = 0 ;
25668 int res1 = 0 ;
25669 bool val2 ;
25670 int ecode2 = 0 ;
25671 PyObject * obj0 = 0 ;
25672 PyObject * obj1 = 0 ;
25673 char * kwnames[] = {
25674 (char *) "self",(char *) "forward", NULL
25675 };
25676
25677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25679 if (!SWIG_IsOK(res1)) {
25680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25681 }
25682 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25684 if (!SWIG_IsOK(ecode2)) {
25685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25686 }
25687 arg2 = static_cast< bool >(val2);
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 (arg1)->SetDirection(arg2);
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 resultobj = SWIG_Py_Void();
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25702 PyObject *resultobj = 0;
25703 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25704 bool result;
25705 void *argp1 = 0 ;
25706 int res1 = 0 ;
25707 PyObject *swig_obj[1] ;
25708
25709 if (!args) SWIG_fail;
25710 swig_obj[0] = args;
25711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25712 if (!SWIG_IsOK(res1)) {
25713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25714 }
25715 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25716 {
25717 PyThreadState* __tstate = wxPyBeginAllowThreads();
25718 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25719 wxPyEndAllowThreads(__tstate);
25720 if (PyErr_Occurred()) SWIG_fail;
25721 }
25722 {
25723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25724 }
25725 return resultobj;
25726 fail:
25727 return NULL;
25728 }
25729
25730
25731 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25732 PyObject *resultobj = 0;
25733 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25734 bool arg2 ;
25735 void *argp1 = 0 ;
25736 int res1 = 0 ;
25737 bool val2 ;
25738 int ecode2 = 0 ;
25739 PyObject * obj0 = 0 ;
25740 PyObject * obj1 = 0 ;
25741 char * kwnames[] = {
25742 (char *) "self",(char *) "ischange", NULL
25743 };
25744
25745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25747 if (!SWIG_IsOK(res1)) {
25748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25749 }
25750 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25751 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25752 if (!SWIG_IsOK(ecode2)) {
25753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25754 }
25755 arg2 = static_cast< bool >(val2);
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 (arg1)->SetWindowChange(arg2);
25759 wxPyEndAllowThreads(__tstate);
25760 if (PyErr_Occurred()) SWIG_fail;
25761 }
25762 resultobj = SWIG_Py_Void();
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25770 PyObject *resultobj = 0;
25771 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25772 bool result;
25773 void *argp1 = 0 ;
25774 int res1 = 0 ;
25775 PyObject *swig_obj[1] ;
25776
25777 if (!args) SWIG_fail;
25778 swig_obj[0] = args;
25779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25780 if (!SWIG_IsOK(res1)) {
25781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25782 }
25783 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25787 wxPyEndAllowThreads(__tstate);
25788 if (PyErr_Occurred()) SWIG_fail;
25789 }
25790 {
25791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25792 }
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25800 PyObject *resultobj = 0;
25801 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25802 bool arg2 ;
25803 void *argp1 = 0 ;
25804 int res1 = 0 ;
25805 bool val2 ;
25806 int ecode2 = 0 ;
25807 PyObject * obj0 = 0 ;
25808 PyObject * obj1 = 0 ;
25809 char * kwnames[] = {
25810 (char *) "self",(char *) "bIs", NULL
25811 };
25812
25813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25815 if (!SWIG_IsOK(res1)) {
25816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25817 }
25818 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25819 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25820 if (!SWIG_IsOK(ecode2)) {
25821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25822 }
25823 arg2 = static_cast< bool >(val2);
25824 {
25825 PyThreadState* __tstate = wxPyBeginAllowThreads();
25826 (arg1)->SetFromTab(arg2);
25827 wxPyEndAllowThreads(__tstate);
25828 if (PyErr_Occurred()) SWIG_fail;
25829 }
25830 resultobj = SWIG_Py_Void();
25831 return resultobj;
25832 fail:
25833 return NULL;
25834 }
25835
25836
25837 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25838 PyObject *resultobj = 0;
25839 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25840 long arg2 ;
25841 void *argp1 = 0 ;
25842 int res1 = 0 ;
25843 long val2 ;
25844 int ecode2 = 0 ;
25845 PyObject * obj0 = 0 ;
25846 PyObject * obj1 = 0 ;
25847 char * kwnames[] = {
25848 (char *) "self",(char *) "flags", NULL
25849 };
25850
25851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25853 if (!SWIG_IsOK(res1)) {
25854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25855 }
25856 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25857 ecode2 = SWIG_AsVal_long(obj1, &val2);
25858 if (!SWIG_IsOK(ecode2)) {
25859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25860 }
25861 arg2 = static_cast< long >(val2);
25862 {
25863 PyThreadState* __tstate = wxPyBeginAllowThreads();
25864 (arg1)->SetFlags(arg2);
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 resultobj = SWIG_Py_Void();
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25876 PyObject *resultobj = 0;
25877 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25878 wxWindow *result = 0 ;
25879 void *argp1 = 0 ;
25880 int res1 = 0 ;
25881 PyObject *swig_obj[1] ;
25882
25883 if (!args) SWIG_fail;
25884 swig_obj[0] = args;
25885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25886 if (!SWIG_IsOK(res1)) {
25887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25888 }
25889 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25893 wxPyEndAllowThreads(__tstate);
25894 if (PyErr_Occurred()) SWIG_fail;
25895 }
25896 {
25897 resultobj = wxPyMake_wxObject(result, (bool)0);
25898 }
25899 return resultobj;
25900 fail:
25901 return NULL;
25902 }
25903
25904
25905 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25906 PyObject *resultobj = 0;
25907 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25908 wxWindow *arg2 = (wxWindow *) 0 ;
25909 void *argp1 = 0 ;
25910 int res1 = 0 ;
25911 void *argp2 = 0 ;
25912 int res2 = 0 ;
25913 PyObject * obj0 = 0 ;
25914 PyObject * obj1 = 0 ;
25915 char * kwnames[] = {
25916 (char *) "self",(char *) "win", NULL
25917 };
25918
25919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25921 if (!SWIG_IsOK(res1)) {
25922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25923 }
25924 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25926 if (!SWIG_IsOK(res2)) {
25927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25928 }
25929 arg2 = reinterpret_cast< wxWindow * >(argp2);
25930 {
25931 PyThreadState* __tstate = wxPyBeginAllowThreads();
25932 (arg1)->SetCurrentFocus(arg2);
25933 wxPyEndAllowThreads(__tstate);
25934 if (PyErr_Occurred()) SWIG_fail;
25935 }
25936 resultobj = SWIG_Py_Void();
25937 return resultobj;
25938 fail:
25939 return NULL;
25940 }
25941
25942
25943 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25944 PyObject *obj;
25945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25946 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25947 return SWIG_Py_Void();
25948 }
25949
25950 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25951 return SWIG_Python_InitShadowInstance(args);
25952 }
25953
25954 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25955 PyObject *resultobj = 0;
25956 wxWindow *arg1 = (wxWindow *) NULL ;
25957 wxWindowCreateEvent *result = 0 ;
25958 void *argp1 = 0 ;
25959 int res1 = 0 ;
25960 PyObject * obj0 = 0 ;
25961 char * kwnames[] = {
25962 (char *) "win", NULL
25963 };
25964
25965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25966 if (obj0) {
25967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25968 if (!SWIG_IsOK(res1)) {
25969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25970 }
25971 arg1 = reinterpret_cast< wxWindow * >(argp1);
25972 }
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25987 PyObject *resultobj = 0;
25988 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25989 wxWindow *result = 0 ;
25990 void *argp1 = 0 ;
25991 int res1 = 0 ;
25992 PyObject *swig_obj[1] ;
25993
25994 if (!args) SWIG_fail;
25995 swig_obj[0] = args;
25996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25997 if (!SWIG_IsOK(res1)) {
25998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25999 }
26000 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 {
26008 resultobj = wxPyMake_wxObject(result, (bool)0);
26009 }
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26017 PyObject *obj;
26018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26019 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26020 return SWIG_Py_Void();
26021 }
26022
26023 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26024 return SWIG_Python_InitShadowInstance(args);
26025 }
26026
26027 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj = 0;
26029 wxWindow *arg1 = (wxWindow *) NULL ;
26030 wxWindowDestroyEvent *result = 0 ;
26031 void *argp1 = 0 ;
26032 int res1 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 char * kwnames[] = {
26035 (char *) "win", NULL
26036 };
26037
26038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26039 if (obj0) {
26040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26043 }
26044 arg1 = reinterpret_cast< wxWindow * >(argp1);
26045 }
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26053 return resultobj;
26054 fail:
26055 return NULL;
26056 }
26057
26058
26059 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26060 PyObject *resultobj = 0;
26061 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26062 wxWindow *result = 0 ;
26063 void *argp1 = 0 ;
26064 int res1 = 0 ;
26065 PyObject *swig_obj[1] ;
26066
26067 if (!args) SWIG_fail;
26068 swig_obj[0] = args;
26069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26070 if (!SWIG_IsOK(res1)) {
26071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26072 }
26073 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26074 {
26075 PyThreadState* __tstate = wxPyBeginAllowThreads();
26076 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26077 wxPyEndAllowThreads(__tstate);
26078 if (PyErr_Occurred()) SWIG_fail;
26079 }
26080 {
26081 resultobj = wxPyMake_wxObject(result, (bool)0);
26082 }
26083 return resultobj;
26084 fail:
26085 return NULL;
26086 }
26087
26088
26089 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26090 PyObject *obj;
26091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26092 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26093 return SWIG_Py_Void();
26094 }
26095
26096 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26097 return SWIG_Python_InitShadowInstance(args);
26098 }
26099
26100 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj = 0;
26102 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26103 int arg2 = (int) 0 ;
26104 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26105 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26106 wxContextMenuEvent *result = 0 ;
26107 int val1 ;
26108 int ecode1 = 0 ;
26109 int val2 ;
26110 int ecode2 = 0 ;
26111 wxPoint temp3 ;
26112 PyObject * obj0 = 0 ;
26113 PyObject * obj1 = 0 ;
26114 PyObject * obj2 = 0 ;
26115 char * kwnames[] = {
26116 (char *) "type",(char *) "winid",(char *) "pt", NULL
26117 };
26118
26119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26120 if (obj0) {
26121 ecode1 = SWIG_AsVal_int(obj0, &val1);
26122 if (!SWIG_IsOK(ecode1)) {
26123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26124 }
26125 arg1 = static_cast< wxEventType >(val1);
26126 }
26127 if (obj1) {
26128 ecode2 = SWIG_AsVal_int(obj1, &val2);
26129 if (!SWIG_IsOK(ecode2)) {
26130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26131 }
26132 arg2 = static_cast< int >(val2);
26133 }
26134 if (obj2) {
26135 {
26136 arg3 = &temp3;
26137 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26138 }
26139 }
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26143 wxPyEndAllowThreads(__tstate);
26144 if (PyErr_Occurred()) SWIG_fail;
26145 }
26146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26154 PyObject *resultobj = 0;
26155 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26156 wxPoint *result = 0 ;
26157 void *argp1 = 0 ;
26158 int res1 = 0 ;
26159 PyObject *swig_obj[1] ;
26160
26161 if (!args) SWIG_fail;
26162 swig_obj[0] = args;
26163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26164 if (!SWIG_IsOK(res1)) {
26165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26166 }
26167 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26168 {
26169 PyThreadState* __tstate = wxPyBeginAllowThreads();
26170 {
26171 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26172 result = (wxPoint *) &_result_ref;
26173 }
26174 wxPyEndAllowThreads(__tstate);
26175 if (PyErr_Occurred()) SWIG_fail;
26176 }
26177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26178 return resultobj;
26179 fail:
26180 return NULL;
26181 }
26182
26183
26184 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26185 PyObject *resultobj = 0;
26186 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26187 wxPoint *arg2 = 0 ;
26188 void *argp1 = 0 ;
26189 int res1 = 0 ;
26190 wxPoint temp2 ;
26191 PyObject * obj0 = 0 ;
26192 PyObject * obj1 = 0 ;
26193 char * kwnames[] = {
26194 (char *) "self",(char *) "pos", NULL
26195 };
26196
26197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26199 if (!SWIG_IsOK(res1)) {
26200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26201 }
26202 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26203 {
26204 arg2 = &temp2;
26205 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26206 }
26207 {
26208 PyThreadState* __tstate = wxPyBeginAllowThreads();
26209 (arg1)->SetPosition((wxPoint const &)*arg2);
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 resultobj = SWIG_Py_Void();
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26221 PyObject *obj;
26222 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26223 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26224 return SWIG_Py_Void();
26225 }
26226
26227 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26228 return SWIG_Python_InitShadowInstance(args);
26229 }
26230
26231 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26232 PyObject *resultobj = 0;
26233 wxIdleEvent *result = 0 ;
26234
26235 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26236 {
26237 PyThreadState* __tstate = wxPyBeginAllowThreads();
26238 result = (wxIdleEvent *)new wxIdleEvent();
26239 wxPyEndAllowThreads(__tstate);
26240 if (PyErr_Occurred()) SWIG_fail;
26241 }
26242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj = 0;
26251 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26252 bool arg2 = (bool) true ;
26253 void *argp1 = 0 ;
26254 int res1 = 0 ;
26255 bool val2 ;
26256 int ecode2 = 0 ;
26257 PyObject * obj0 = 0 ;
26258 PyObject * obj1 = 0 ;
26259 char * kwnames[] = {
26260 (char *) "self",(char *) "needMore", NULL
26261 };
26262
26263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26265 if (!SWIG_IsOK(res1)) {
26266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26267 }
26268 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26269 if (obj1) {
26270 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26271 if (!SWIG_IsOK(ecode2)) {
26272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26273 }
26274 arg2 = static_cast< bool >(val2);
26275 }
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 (arg1)->RequestMore(arg2);
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_Py_Void();
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 PyObject *resultobj = 0;
26291 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26292 bool result;
26293 void *argp1 = 0 ;
26294 int res1 = 0 ;
26295 PyObject *swig_obj[1] ;
26296
26297 if (!args) SWIG_fail;
26298 swig_obj[0] = args;
26299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26300 if (!SWIG_IsOK(res1)) {
26301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26302 }
26303 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 {
26311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26312 }
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj = 0;
26321 wxIdleMode arg1 ;
26322 int val1 ;
26323 int ecode1 = 0 ;
26324 PyObject * obj0 = 0 ;
26325 char * kwnames[] = {
26326 (char *) "mode", NULL
26327 };
26328
26329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26330 ecode1 = SWIG_AsVal_int(obj0, &val1);
26331 if (!SWIG_IsOK(ecode1)) {
26332 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26333 }
26334 arg1 = static_cast< wxIdleMode >(val1);
26335 {
26336 PyThreadState* __tstate = wxPyBeginAllowThreads();
26337 wxIdleEvent::SetMode(arg1);
26338 wxPyEndAllowThreads(__tstate);
26339 if (PyErr_Occurred()) SWIG_fail;
26340 }
26341 resultobj = SWIG_Py_Void();
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26349 PyObject *resultobj = 0;
26350 wxIdleMode result;
26351
26352 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 result = (wxIdleMode)wxIdleEvent::GetMode();
26356 wxPyEndAllowThreads(__tstate);
26357 if (PyErr_Occurred()) SWIG_fail;
26358 }
26359 resultobj = SWIG_From_int(static_cast< int >(result));
26360 return resultobj;
26361 fail:
26362 return NULL;
26363 }
26364
26365
26366 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26367 PyObject *resultobj = 0;
26368 wxWindow *arg1 = (wxWindow *) 0 ;
26369 bool result;
26370 void *argp1 = 0 ;
26371 int res1 = 0 ;
26372 PyObject * obj0 = 0 ;
26373 char * kwnames[] = {
26374 (char *) "win", NULL
26375 };
26376
26377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26379 if (!SWIG_IsOK(res1)) {
26380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26381 }
26382 arg1 = reinterpret_cast< wxWindow * >(argp1);
26383 {
26384 PyThreadState* __tstate = wxPyBeginAllowThreads();
26385 result = (bool)wxIdleEvent::CanSend(arg1);
26386 wxPyEndAllowThreads(__tstate);
26387 if (PyErr_Occurred()) SWIG_fail;
26388 }
26389 {
26390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26391 }
26392 return resultobj;
26393 fail:
26394 return NULL;
26395 }
26396
26397
26398 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26399 PyObject *obj;
26400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26401 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26402 return SWIG_Py_Void();
26403 }
26404
26405 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26406 return SWIG_Python_InitShadowInstance(args);
26407 }
26408
26409 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26410 PyObject *resultobj = 0;
26411 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26412 int arg2 = (int) 0 ;
26413 wxClipboardTextEvent *result = 0 ;
26414 int val1 ;
26415 int ecode1 = 0 ;
26416 int val2 ;
26417 int ecode2 = 0 ;
26418 PyObject * obj0 = 0 ;
26419 PyObject * obj1 = 0 ;
26420 char * kwnames[] = {
26421 (char *) "type",(char *) "winid", NULL
26422 };
26423
26424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26425 if (obj0) {
26426 ecode1 = SWIG_AsVal_int(obj0, &val1);
26427 if (!SWIG_IsOK(ecode1)) {
26428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26429 }
26430 arg1 = static_cast< wxEventType >(val1);
26431 }
26432 if (obj1) {
26433 ecode2 = SWIG_AsVal_int(obj1, &val2);
26434 if (!SWIG_IsOK(ecode2)) {
26435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26436 }
26437 arg2 = static_cast< int >(val2);
26438 }
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26442 wxPyEndAllowThreads(__tstate);
26443 if (PyErr_Occurred()) SWIG_fail;
26444 }
26445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26446 return resultobj;
26447 fail:
26448 return NULL;
26449 }
26450
26451
26452 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26453 PyObject *obj;
26454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26455 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26456 return SWIG_Py_Void();
26457 }
26458
26459 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26460 return SWIG_Python_InitShadowInstance(args);
26461 }
26462
26463 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26464 PyObject *resultobj = 0;
26465 int arg1 = (int) 0 ;
26466 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26467 wxPyEvent *result = 0 ;
26468 int val1 ;
26469 int ecode1 = 0 ;
26470 int val2 ;
26471 int ecode2 = 0 ;
26472 PyObject * obj0 = 0 ;
26473 PyObject * obj1 = 0 ;
26474 char * kwnames[] = {
26475 (char *) "winid",(char *) "eventType", NULL
26476 };
26477
26478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26479 if (obj0) {
26480 ecode1 = SWIG_AsVal_int(obj0, &val1);
26481 if (!SWIG_IsOK(ecode1)) {
26482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26483 }
26484 arg1 = static_cast< int >(val1);
26485 }
26486 if (obj1) {
26487 ecode2 = SWIG_AsVal_int(obj1, &val2);
26488 if (!SWIG_IsOK(ecode2)) {
26489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26490 }
26491 arg2 = static_cast< wxEventType >(val2);
26492 }
26493 {
26494 PyThreadState* __tstate = wxPyBeginAllowThreads();
26495 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26507 PyObject *resultobj = 0;
26508 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26509 void *argp1 = 0 ;
26510 int res1 = 0 ;
26511 PyObject *swig_obj[1] ;
26512
26513 if (!args) SWIG_fail;
26514 swig_obj[0] = args;
26515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26516 if (!SWIG_IsOK(res1)) {
26517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26518 }
26519 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26520 {
26521 PyThreadState* __tstate = wxPyBeginAllowThreads();
26522 delete arg1;
26523
26524 wxPyEndAllowThreads(__tstate);
26525 if (PyErr_Occurred()) SWIG_fail;
26526 }
26527 resultobj = SWIG_Py_Void();
26528 return resultobj;
26529 fail:
26530 return NULL;
26531 }
26532
26533
26534 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26535 PyObject *resultobj = 0;
26536 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26537 PyObject *arg2 = (PyObject *) 0 ;
26538 void *argp1 = 0 ;
26539 int res1 = 0 ;
26540 PyObject * obj0 = 0 ;
26541 PyObject * obj1 = 0 ;
26542 char * kwnames[] = {
26543 (char *) "self",(char *) "self", NULL
26544 };
26545
26546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26548 if (!SWIG_IsOK(res1)) {
26549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26550 }
26551 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26552 arg2 = obj1;
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 (arg1)->SetSelf(arg2);
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 resultobj = SWIG_Py_Void();
26560 return resultobj;
26561 fail:
26562 return NULL;
26563 }
26564
26565
26566 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26567 PyObject *resultobj = 0;
26568 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26569 PyObject *result = 0 ;
26570 void *argp1 = 0 ;
26571 int res1 = 0 ;
26572 PyObject *swig_obj[1] ;
26573
26574 if (!args) SWIG_fail;
26575 swig_obj[0] = args;
26576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26577 if (!SWIG_IsOK(res1)) {
26578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26579 }
26580 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26581 {
26582 PyThreadState* __tstate = wxPyBeginAllowThreads();
26583 result = (PyObject *)(arg1)->GetSelf();
26584 wxPyEndAllowThreads(__tstate);
26585 if (PyErr_Occurred()) SWIG_fail;
26586 }
26587 resultobj = result;
26588 return resultobj;
26589 fail:
26590 return NULL;
26591 }
26592
26593
26594 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26595 PyObject *obj;
26596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26597 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26598 return SWIG_Py_Void();
26599 }
26600
26601 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26602 return SWIG_Python_InitShadowInstance(args);
26603 }
26604
26605 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26606 PyObject *resultobj = 0;
26607 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26608 int arg2 = (int) 0 ;
26609 wxPyCommandEvent *result = 0 ;
26610 int val1 ;
26611 int ecode1 = 0 ;
26612 int val2 ;
26613 int ecode2 = 0 ;
26614 PyObject * obj0 = 0 ;
26615 PyObject * obj1 = 0 ;
26616 char * kwnames[] = {
26617 (char *) "eventType",(char *) "id", NULL
26618 };
26619
26620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26621 if (obj0) {
26622 ecode1 = SWIG_AsVal_int(obj0, &val1);
26623 if (!SWIG_IsOK(ecode1)) {
26624 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26625 }
26626 arg1 = static_cast< wxEventType >(val1);
26627 }
26628 if (obj1) {
26629 ecode2 = SWIG_AsVal_int(obj1, &val2);
26630 if (!SWIG_IsOK(ecode2)) {
26631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26632 }
26633 arg2 = static_cast< int >(val2);
26634 }
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26638 wxPyEndAllowThreads(__tstate);
26639 if (PyErr_Occurred()) SWIG_fail;
26640 }
26641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26642 return resultobj;
26643 fail:
26644 return NULL;
26645 }
26646
26647
26648 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26649 PyObject *resultobj = 0;
26650 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26651 void *argp1 = 0 ;
26652 int res1 = 0 ;
26653 PyObject *swig_obj[1] ;
26654
26655 if (!args) SWIG_fail;
26656 swig_obj[0] = args;
26657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26658 if (!SWIG_IsOK(res1)) {
26659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26660 }
26661 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26662 {
26663 PyThreadState* __tstate = wxPyBeginAllowThreads();
26664 delete arg1;
26665
26666 wxPyEndAllowThreads(__tstate);
26667 if (PyErr_Occurred()) SWIG_fail;
26668 }
26669 resultobj = SWIG_Py_Void();
26670 return resultobj;
26671 fail:
26672 return NULL;
26673 }
26674
26675
26676 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26677 PyObject *resultobj = 0;
26678 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26679 PyObject *arg2 = (PyObject *) 0 ;
26680 void *argp1 = 0 ;
26681 int res1 = 0 ;
26682 PyObject * obj0 = 0 ;
26683 PyObject * obj1 = 0 ;
26684 char * kwnames[] = {
26685 (char *) "self",(char *) "self", NULL
26686 };
26687
26688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26690 if (!SWIG_IsOK(res1)) {
26691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26692 }
26693 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26694 arg2 = obj1;
26695 {
26696 PyThreadState* __tstate = wxPyBeginAllowThreads();
26697 (arg1)->SetSelf(arg2);
26698 wxPyEndAllowThreads(__tstate);
26699 if (PyErr_Occurred()) SWIG_fail;
26700 }
26701 resultobj = SWIG_Py_Void();
26702 return resultobj;
26703 fail:
26704 return NULL;
26705 }
26706
26707
26708 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26709 PyObject *resultobj = 0;
26710 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26711 PyObject *result = 0 ;
26712 void *argp1 = 0 ;
26713 int res1 = 0 ;
26714 PyObject *swig_obj[1] ;
26715
26716 if (!args) SWIG_fail;
26717 swig_obj[0] = args;
26718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26719 if (!SWIG_IsOK(res1)) {
26720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26721 }
26722 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26723 {
26724 PyThreadState* __tstate = wxPyBeginAllowThreads();
26725 result = (PyObject *)(arg1)->GetSelf();
26726 wxPyEndAllowThreads(__tstate);
26727 if (PyErr_Occurred()) SWIG_fail;
26728 }
26729 resultobj = result;
26730 return resultobj;
26731 fail:
26732 return NULL;
26733 }
26734
26735
26736 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26737 PyObject *obj;
26738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26739 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26740 return SWIG_Py_Void();
26741 }
26742
26743 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26744 return SWIG_Python_InitShadowInstance(args);
26745 }
26746
26747 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26748 PyObject *resultobj = 0;
26749 wxWindow *arg1 = (wxWindow *) 0 ;
26750 wxDateTime *arg2 = 0 ;
26751 wxEventType arg3 ;
26752 wxDateEvent *result = 0 ;
26753 void *argp1 = 0 ;
26754 int res1 = 0 ;
26755 void *argp2 = 0 ;
26756 int res2 = 0 ;
26757 int val3 ;
26758 int ecode3 = 0 ;
26759 PyObject * obj0 = 0 ;
26760 PyObject * obj1 = 0 ;
26761 PyObject * obj2 = 0 ;
26762 char * kwnames[] = {
26763 (char *) "win",(char *) "dt",(char *) "type", NULL
26764 };
26765
26766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26768 if (!SWIG_IsOK(res1)) {
26769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26770 }
26771 arg1 = reinterpret_cast< wxWindow * >(argp1);
26772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26773 if (!SWIG_IsOK(res2)) {
26774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26775 }
26776 if (!argp2) {
26777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26778 }
26779 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26780 ecode3 = SWIG_AsVal_int(obj2, &val3);
26781 if (!SWIG_IsOK(ecode3)) {
26782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26783 }
26784 arg3 = static_cast< wxEventType >(val3);
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26792 return resultobj;
26793 fail:
26794 return NULL;
26795 }
26796
26797
26798 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26799 PyObject *resultobj = 0;
26800 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26801 wxDateTime *result = 0 ;
26802 void *argp1 = 0 ;
26803 int res1 = 0 ;
26804 PyObject *swig_obj[1] ;
26805
26806 if (!args) SWIG_fail;
26807 swig_obj[0] = args;
26808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26809 if (!SWIG_IsOK(res1)) {
26810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26811 }
26812 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 {
26816 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26817 result = (wxDateTime *) &_result_ref;
26818 }
26819 wxPyEndAllowThreads(__tstate);
26820 if (PyErr_Occurred()) SWIG_fail;
26821 }
26822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26823 return resultobj;
26824 fail:
26825 return NULL;
26826 }
26827
26828
26829 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26830 PyObject *resultobj = 0;
26831 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26832 wxDateTime *arg2 = 0 ;
26833 void *argp1 = 0 ;
26834 int res1 = 0 ;
26835 void *argp2 = 0 ;
26836 int res2 = 0 ;
26837 PyObject * obj0 = 0 ;
26838 PyObject * obj1 = 0 ;
26839 char * kwnames[] = {
26840 (char *) "self",(char *) "date", NULL
26841 };
26842
26843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26845 if (!SWIG_IsOK(res1)) {
26846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26847 }
26848 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26849 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26850 if (!SWIG_IsOK(res2)) {
26851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26852 }
26853 if (!argp2) {
26854 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26855 }
26856 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26857 {
26858 PyThreadState* __tstate = wxPyBeginAllowThreads();
26859 (arg1)->SetDate((wxDateTime const &)*arg2);
26860 wxPyEndAllowThreads(__tstate);
26861 if (PyErr_Occurred()) SWIG_fail;
26862 }
26863 resultobj = SWIG_Py_Void();
26864 return resultobj;
26865 fail:
26866 return NULL;
26867 }
26868
26869
26870 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26871 PyObject *obj;
26872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26873 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26874 return SWIG_Py_Void();
26875 }
26876
26877 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26878 return SWIG_Python_InitShadowInstance(args);
26879 }
26880
26881 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26882 PyObject *resultobj = 0;
26883 wxPyApp *result = 0 ;
26884
26885 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 result = (wxPyApp *)new_wxPyApp();
26889 wxPyEndAllowThreads(__tstate);
26890 if (PyErr_Occurred()) SWIG_fail;
26891 }
26892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26893 return resultobj;
26894 fail:
26895 return NULL;
26896 }
26897
26898
26899 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26900 PyObject *resultobj = 0;
26901 wxPyApp *arg1 = (wxPyApp *) 0 ;
26902 void *argp1 = 0 ;
26903 int res1 = 0 ;
26904 PyObject *swig_obj[1] ;
26905
26906 if (!args) SWIG_fail;
26907 swig_obj[0] = args;
26908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26909 if (!SWIG_IsOK(res1)) {
26910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26911 }
26912 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 delete arg1;
26916
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 resultobj = SWIG_Py_Void();
26921 return resultobj;
26922 fail:
26923 return NULL;
26924 }
26925
26926
26927 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26928 PyObject *resultobj = 0;
26929 wxPyApp *arg1 = (wxPyApp *) 0 ;
26930 PyObject *arg2 = (PyObject *) 0 ;
26931 PyObject *arg3 = (PyObject *) 0 ;
26932 bool arg4 ;
26933 void *argp1 = 0 ;
26934 int res1 = 0 ;
26935 bool val4 ;
26936 int ecode4 = 0 ;
26937 PyObject * obj0 = 0 ;
26938 PyObject * obj1 = 0 ;
26939 PyObject * obj2 = 0 ;
26940 PyObject * obj3 = 0 ;
26941 char * kwnames[] = {
26942 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26943 };
26944
26945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26947 if (!SWIG_IsOK(res1)) {
26948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26949 }
26950 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26951 arg2 = obj1;
26952 arg3 = obj2;
26953 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26954 if (!SWIG_IsOK(ecode4)) {
26955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26956 }
26957 arg4 = static_cast< bool >(val4);
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 resultobj = SWIG_Py_Void();
26965 return resultobj;
26966 fail:
26967 return NULL;
26968 }
26969
26970
26971 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26972 PyObject *resultobj = 0;
26973 wxPyApp *arg1 = (wxPyApp *) 0 ;
26974 wxString result;
26975 void *argp1 = 0 ;
26976 int res1 = 0 ;
26977 PyObject *swig_obj[1] ;
26978
26979 if (!args) SWIG_fail;
26980 swig_obj[0] = args;
26981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26982 if (!SWIG_IsOK(res1)) {
26983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26984 }
26985 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26986 {
26987 PyThreadState* __tstate = wxPyBeginAllowThreads();
26988 result = ((wxPyApp const *)arg1)->GetAppName();
26989 wxPyEndAllowThreads(__tstate);
26990 if (PyErr_Occurred()) SWIG_fail;
26991 }
26992 {
26993 #if wxUSE_UNICODE
26994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26995 #else
26996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26997 #endif
26998 }
26999 return resultobj;
27000 fail:
27001 return NULL;
27002 }
27003
27004
27005 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27006 PyObject *resultobj = 0;
27007 wxPyApp *arg1 = (wxPyApp *) 0 ;
27008 wxString *arg2 = 0 ;
27009 void *argp1 = 0 ;
27010 int res1 = 0 ;
27011 bool temp2 = false ;
27012 PyObject * obj0 = 0 ;
27013 PyObject * obj1 = 0 ;
27014 char * kwnames[] = {
27015 (char *) "self",(char *) "name", NULL
27016 };
27017
27018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27020 if (!SWIG_IsOK(res1)) {
27021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27022 }
27023 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27024 {
27025 arg2 = wxString_in_helper(obj1);
27026 if (arg2 == NULL) SWIG_fail;
27027 temp2 = true;
27028 }
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 (arg1)->SetAppName((wxString const &)*arg2);
27032 wxPyEndAllowThreads(__tstate);
27033 if (PyErr_Occurred()) SWIG_fail;
27034 }
27035 resultobj = SWIG_Py_Void();
27036 {
27037 if (temp2)
27038 delete arg2;
27039 }
27040 return resultobj;
27041 fail:
27042 {
27043 if (temp2)
27044 delete arg2;
27045 }
27046 return NULL;
27047 }
27048
27049
27050 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27051 PyObject *resultobj = 0;
27052 wxPyApp *arg1 = (wxPyApp *) 0 ;
27053 wxString result;
27054 void *argp1 = 0 ;
27055 int res1 = 0 ;
27056 PyObject *swig_obj[1] ;
27057
27058 if (!args) SWIG_fail;
27059 swig_obj[0] = args;
27060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27061 if (!SWIG_IsOK(res1)) {
27062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27063 }
27064 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27065 {
27066 PyThreadState* __tstate = wxPyBeginAllowThreads();
27067 result = ((wxPyApp const *)arg1)->GetClassName();
27068 wxPyEndAllowThreads(__tstate);
27069 if (PyErr_Occurred()) SWIG_fail;
27070 }
27071 {
27072 #if wxUSE_UNICODE
27073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27074 #else
27075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27076 #endif
27077 }
27078 return resultobj;
27079 fail:
27080 return NULL;
27081 }
27082
27083
27084 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27085 PyObject *resultobj = 0;
27086 wxPyApp *arg1 = (wxPyApp *) 0 ;
27087 wxString *arg2 = 0 ;
27088 void *argp1 = 0 ;
27089 int res1 = 0 ;
27090 bool temp2 = false ;
27091 PyObject * obj0 = 0 ;
27092 PyObject * obj1 = 0 ;
27093 char * kwnames[] = {
27094 (char *) "self",(char *) "name", NULL
27095 };
27096
27097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27099 if (!SWIG_IsOK(res1)) {
27100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27101 }
27102 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27103 {
27104 arg2 = wxString_in_helper(obj1);
27105 if (arg2 == NULL) SWIG_fail;
27106 temp2 = true;
27107 }
27108 {
27109 PyThreadState* __tstate = wxPyBeginAllowThreads();
27110 (arg1)->SetClassName((wxString const &)*arg2);
27111 wxPyEndAllowThreads(__tstate);
27112 if (PyErr_Occurred()) SWIG_fail;
27113 }
27114 resultobj = SWIG_Py_Void();
27115 {
27116 if (temp2)
27117 delete arg2;
27118 }
27119 return resultobj;
27120 fail:
27121 {
27122 if (temp2)
27123 delete arg2;
27124 }
27125 return NULL;
27126 }
27127
27128
27129 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27130 PyObject *resultobj = 0;
27131 wxPyApp *arg1 = (wxPyApp *) 0 ;
27132 wxString *result = 0 ;
27133 void *argp1 = 0 ;
27134 int res1 = 0 ;
27135 PyObject *swig_obj[1] ;
27136
27137 if (!args) SWIG_fail;
27138 swig_obj[0] = args;
27139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27140 if (!SWIG_IsOK(res1)) {
27141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27142 }
27143 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27144 {
27145 PyThreadState* __tstate = wxPyBeginAllowThreads();
27146 {
27147 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27148 result = (wxString *) &_result_ref;
27149 }
27150 wxPyEndAllowThreads(__tstate);
27151 if (PyErr_Occurred()) SWIG_fail;
27152 }
27153 {
27154 #if wxUSE_UNICODE
27155 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27156 #else
27157 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27158 #endif
27159 }
27160 return resultobj;
27161 fail:
27162 return NULL;
27163 }
27164
27165
27166 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27167 PyObject *resultobj = 0;
27168 wxPyApp *arg1 = (wxPyApp *) 0 ;
27169 wxString *arg2 = 0 ;
27170 void *argp1 = 0 ;
27171 int res1 = 0 ;
27172 bool temp2 = false ;
27173 PyObject * obj0 = 0 ;
27174 PyObject * obj1 = 0 ;
27175 char * kwnames[] = {
27176 (char *) "self",(char *) "name", NULL
27177 };
27178
27179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27181 if (!SWIG_IsOK(res1)) {
27182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27183 }
27184 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27185 {
27186 arg2 = wxString_in_helper(obj1);
27187 if (arg2 == NULL) SWIG_fail;
27188 temp2 = true;
27189 }
27190 {
27191 PyThreadState* __tstate = wxPyBeginAllowThreads();
27192 (arg1)->SetVendorName((wxString const &)*arg2);
27193 wxPyEndAllowThreads(__tstate);
27194 if (PyErr_Occurred()) SWIG_fail;
27195 }
27196 resultobj = SWIG_Py_Void();
27197 {
27198 if (temp2)
27199 delete arg2;
27200 }
27201 return resultobj;
27202 fail:
27203 {
27204 if (temp2)
27205 delete arg2;
27206 }
27207 return NULL;
27208 }
27209
27210
27211 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27212 PyObject *resultobj = 0;
27213 wxPyApp *arg1 = (wxPyApp *) 0 ;
27214 wxAppTraits *result = 0 ;
27215 void *argp1 = 0 ;
27216 int res1 = 0 ;
27217 PyObject *swig_obj[1] ;
27218
27219 if (!args) SWIG_fail;
27220 swig_obj[0] = args;
27221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27222 if (!SWIG_IsOK(res1)) {
27223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27224 }
27225 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27226 {
27227 PyThreadState* __tstate = wxPyBeginAllowThreads();
27228 result = (wxAppTraits *)(arg1)->GetTraits();
27229 wxPyEndAllowThreads(__tstate);
27230 if (PyErr_Occurred()) SWIG_fail;
27231 }
27232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27233 return resultobj;
27234 fail:
27235 return NULL;
27236 }
27237
27238
27239 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27240 PyObject *resultobj = 0;
27241 wxPyApp *arg1 = (wxPyApp *) 0 ;
27242 void *argp1 = 0 ;
27243 int res1 = 0 ;
27244 PyObject *swig_obj[1] ;
27245
27246 if (!args) SWIG_fail;
27247 swig_obj[0] = args;
27248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27249 if (!SWIG_IsOK(res1)) {
27250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27251 }
27252 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 (arg1)->ProcessPendingEvents();
27256 wxPyEndAllowThreads(__tstate);
27257 if (PyErr_Occurred()) SWIG_fail;
27258 }
27259 resultobj = SWIG_Py_Void();
27260 return resultobj;
27261 fail:
27262 return NULL;
27263 }
27264
27265
27266 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27267 PyObject *resultobj = 0;
27268 wxPyApp *arg1 = (wxPyApp *) 0 ;
27269 bool arg2 = (bool) false ;
27270 bool result;
27271 void *argp1 = 0 ;
27272 int res1 = 0 ;
27273 bool val2 ;
27274 int ecode2 = 0 ;
27275 PyObject * obj0 = 0 ;
27276 PyObject * obj1 = 0 ;
27277 char * kwnames[] = {
27278 (char *) "self",(char *) "onlyIfNeeded", NULL
27279 };
27280
27281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27283 if (!SWIG_IsOK(res1)) {
27284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27285 }
27286 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27287 if (obj1) {
27288 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27289 if (!SWIG_IsOK(ecode2)) {
27290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27291 }
27292 arg2 = static_cast< bool >(val2);
27293 }
27294 {
27295 PyThreadState* __tstate = wxPyBeginAllowThreads();
27296 result = (bool)(arg1)->Yield(arg2);
27297 wxPyEndAllowThreads(__tstate);
27298 if (PyErr_Occurred()) SWIG_fail;
27299 }
27300 {
27301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27302 }
27303 return resultobj;
27304 fail:
27305 return NULL;
27306 }
27307
27308
27309 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27310 PyObject *resultobj = 0;
27311 wxPyApp *arg1 = (wxPyApp *) 0 ;
27312 void *argp1 = 0 ;
27313 int res1 = 0 ;
27314 PyObject *swig_obj[1] ;
27315
27316 if (!args) SWIG_fail;
27317 swig_obj[0] = args;
27318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27319 if (!SWIG_IsOK(res1)) {
27320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27321 }
27322 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27323 {
27324 PyThreadState* __tstate = wxPyBeginAllowThreads();
27325 (arg1)->WakeUpIdle();
27326 wxPyEndAllowThreads(__tstate);
27327 if (PyErr_Occurred()) SWIG_fail;
27328 }
27329 resultobj = SWIG_Py_Void();
27330 return resultobj;
27331 fail:
27332 return NULL;
27333 }
27334
27335
27336 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27337 PyObject *resultobj = 0;
27338 bool result;
27339
27340 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27341 {
27342 PyThreadState* __tstate = wxPyBeginAllowThreads();
27343 result = (bool)wxPyApp::IsMainLoopRunning();
27344 wxPyEndAllowThreads(__tstate);
27345 if (PyErr_Occurred()) SWIG_fail;
27346 }
27347 {
27348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27349 }
27350 return resultobj;
27351 fail:
27352 return NULL;
27353 }
27354
27355
27356 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27357 PyObject *resultobj = 0;
27358 wxPyApp *arg1 = (wxPyApp *) 0 ;
27359 int result;
27360 void *argp1 = 0 ;
27361 int res1 = 0 ;
27362 PyObject *swig_obj[1] ;
27363
27364 if (!args) SWIG_fail;
27365 swig_obj[0] = args;
27366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27367 if (!SWIG_IsOK(res1)) {
27368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27369 }
27370 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27371 {
27372 PyThreadState* __tstate = wxPyBeginAllowThreads();
27373 result = (int)(arg1)->MainLoop();
27374 wxPyEndAllowThreads(__tstate);
27375 if (PyErr_Occurred()) SWIG_fail;
27376 }
27377 resultobj = SWIG_From_int(static_cast< int >(result));
27378 return resultobj;
27379 fail:
27380 return NULL;
27381 }
27382
27383
27384 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27385 PyObject *resultobj = 0;
27386 wxPyApp *arg1 = (wxPyApp *) 0 ;
27387 void *argp1 = 0 ;
27388 int res1 = 0 ;
27389 PyObject *swig_obj[1] ;
27390
27391 if (!args) SWIG_fail;
27392 swig_obj[0] = args;
27393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27394 if (!SWIG_IsOK(res1)) {
27395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27396 }
27397 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27398 {
27399 PyThreadState* __tstate = wxPyBeginAllowThreads();
27400 (arg1)->Exit();
27401 wxPyEndAllowThreads(__tstate);
27402 if (PyErr_Occurred()) SWIG_fail;
27403 }
27404 resultobj = SWIG_Py_Void();
27405 return resultobj;
27406 fail:
27407 return NULL;
27408 }
27409
27410
27411 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27412 PyObject *resultobj = 0;
27413 wxPyApp *arg1 = (wxPyApp *) 0 ;
27414 void *argp1 = 0 ;
27415 int res1 = 0 ;
27416 PyObject *swig_obj[1] ;
27417
27418 if (!args) SWIG_fail;
27419 swig_obj[0] = args;
27420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27421 if (!SWIG_IsOK(res1)) {
27422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27423 }
27424 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 (arg1)->ExitMainLoop();
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 resultobj = SWIG_Py_Void();
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27439 PyObject *resultobj = 0;
27440 wxPyApp *arg1 = (wxPyApp *) 0 ;
27441 bool result;
27442 void *argp1 = 0 ;
27443 int res1 = 0 ;
27444 PyObject *swig_obj[1] ;
27445
27446 if (!args) SWIG_fail;
27447 swig_obj[0] = args;
27448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27449 if (!SWIG_IsOK(res1)) {
27450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27451 }
27452 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 result = (bool)(arg1)->Pending();
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 {
27460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27461 }
27462 return resultobj;
27463 fail:
27464 return NULL;
27465 }
27466
27467
27468 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27469 PyObject *resultobj = 0;
27470 wxPyApp *arg1 = (wxPyApp *) 0 ;
27471 bool result;
27472 void *argp1 = 0 ;
27473 int res1 = 0 ;
27474 PyObject *swig_obj[1] ;
27475
27476 if (!args) SWIG_fail;
27477 swig_obj[0] = args;
27478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27479 if (!SWIG_IsOK(res1)) {
27480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27481 }
27482 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 result = (bool)(arg1)->Dispatch();
27486 wxPyEndAllowThreads(__tstate);
27487 if (PyErr_Occurred()) SWIG_fail;
27488 }
27489 {
27490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27491 }
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27499 PyObject *resultobj = 0;
27500 wxPyApp *arg1 = (wxPyApp *) 0 ;
27501 bool result;
27502 void *argp1 = 0 ;
27503 int res1 = 0 ;
27504 PyObject *swig_obj[1] ;
27505
27506 if (!args) SWIG_fail;
27507 swig_obj[0] = args;
27508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27509 if (!SWIG_IsOK(res1)) {
27510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27511 }
27512 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27513 {
27514 PyThreadState* __tstate = wxPyBeginAllowThreads();
27515 result = (bool)(arg1)->ProcessIdle();
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 {
27520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27521 }
27522 return resultobj;
27523 fail:
27524 return NULL;
27525 }
27526
27527
27528 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27529 PyObject *resultobj = 0;
27530 wxPyApp *arg1 = (wxPyApp *) 0 ;
27531 wxWindow *arg2 = (wxWindow *) 0 ;
27532 wxIdleEvent *arg3 = 0 ;
27533 bool result;
27534 void *argp1 = 0 ;
27535 int res1 = 0 ;
27536 void *argp2 = 0 ;
27537 int res2 = 0 ;
27538 void *argp3 = 0 ;
27539 int res3 = 0 ;
27540 PyObject * obj0 = 0 ;
27541 PyObject * obj1 = 0 ;
27542 PyObject * obj2 = 0 ;
27543 char * kwnames[] = {
27544 (char *) "self",(char *) "win",(char *) "event", NULL
27545 };
27546
27547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27549 if (!SWIG_IsOK(res1)) {
27550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27551 }
27552 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27554 if (!SWIG_IsOK(res2)) {
27555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27556 }
27557 arg2 = reinterpret_cast< wxWindow * >(argp2);
27558 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27559 if (!SWIG_IsOK(res3)) {
27560 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27561 }
27562 if (!argp3) {
27563 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27564 }
27565 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27566 {
27567 PyThreadState* __tstate = wxPyBeginAllowThreads();
27568 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27569 wxPyEndAllowThreads(__tstate);
27570 if (PyErr_Occurred()) SWIG_fail;
27571 }
27572 {
27573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27574 }
27575 return resultobj;
27576 fail:
27577 return NULL;
27578 }
27579
27580
27581 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27582 PyObject *resultobj = 0;
27583 wxPyApp *arg1 = (wxPyApp *) 0 ;
27584 bool result;
27585 void *argp1 = 0 ;
27586 int res1 = 0 ;
27587 PyObject *swig_obj[1] ;
27588
27589 if (!args) SWIG_fail;
27590 swig_obj[0] = args;
27591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27592 if (!SWIG_IsOK(res1)) {
27593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27594 }
27595 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27596 {
27597 PyThreadState* __tstate = wxPyBeginAllowThreads();
27598 result = (bool)((wxPyApp const *)arg1)->IsActive();
27599 wxPyEndAllowThreads(__tstate);
27600 if (PyErr_Occurred()) SWIG_fail;
27601 }
27602 {
27603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27604 }
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27612 PyObject *resultobj = 0;
27613 wxPyApp *arg1 = (wxPyApp *) 0 ;
27614 wxWindow *arg2 = (wxWindow *) 0 ;
27615 void *argp1 = 0 ;
27616 int res1 = 0 ;
27617 void *argp2 = 0 ;
27618 int res2 = 0 ;
27619 PyObject * obj0 = 0 ;
27620 PyObject * obj1 = 0 ;
27621 char * kwnames[] = {
27622 (char *) "self",(char *) "win", NULL
27623 };
27624
27625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27627 if (!SWIG_IsOK(res1)) {
27628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27629 }
27630 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27631 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27632 if (!SWIG_IsOK(res2)) {
27633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27634 }
27635 arg2 = reinterpret_cast< wxWindow * >(argp2);
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 (arg1)->SetTopWindow(arg2);
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 resultobj = SWIG_Py_Void();
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27650 PyObject *resultobj = 0;
27651 wxPyApp *arg1 = (wxPyApp *) 0 ;
27652 wxWindow *result = 0 ;
27653 void *argp1 = 0 ;
27654 int res1 = 0 ;
27655 PyObject *swig_obj[1] ;
27656
27657 if (!args) SWIG_fail;
27658 swig_obj[0] = args;
27659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27660 if (!SWIG_IsOK(res1)) {
27661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27662 }
27663 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27664 {
27665 PyThreadState* __tstate = wxPyBeginAllowThreads();
27666 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 {
27671 resultobj = wxPyMake_wxObject(result, (bool)0);
27672 }
27673 return resultobj;
27674 fail:
27675 return NULL;
27676 }
27677
27678
27679 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27680 PyObject *resultobj = 0;
27681 wxPyApp *arg1 = (wxPyApp *) 0 ;
27682 bool arg2 ;
27683 void *argp1 = 0 ;
27684 int res1 = 0 ;
27685 bool val2 ;
27686 int ecode2 = 0 ;
27687 PyObject * obj0 = 0 ;
27688 PyObject * obj1 = 0 ;
27689 char * kwnames[] = {
27690 (char *) "self",(char *) "flag", NULL
27691 };
27692
27693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27695 if (!SWIG_IsOK(res1)) {
27696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27697 }
27698 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27700 if (!SWIG_IsOK(ecode2)) {
27701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27702 }
27703 arg2 = static_cast< bool >(val2);
27704 {
27705 PyThreadState* __tstate = wxPyBeginAllowThreads();
27706 (arg1)->SetExitOnFrameDelete(arg2);
27707 wxPyEndAllowThreads(__tstate);
27708 if (PyErr_Occurred()) SWIG_fail;
27709 }
27710 resultobj = SWIG_Py_Void();
27711 return resultobj;
27712 fail:
27713 return NULL;
27714 }
27715
27716
27717 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27718 PyObject *resultobj = 0;
27719 wxPyApp *arg1 = (wxPyApp *) 0 ;
27720 bool result;
27721 void *argp1 = 0 ;
27722 int res1 = 0 ;
27723 PyObject *swig_obj[1] ;
27724
27725 if (!args) SWIG_fail;
27726 swig_obj[0] = args;
27727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27728 if (!SWIG_IsOK(res1)) {
27729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27730 }
27731 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27732 {
27733 PyThreadState* __tstate = wxPyBeginAllowThreads();
27734 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27735 wxPyEndAllowThreads(__tstate);
27736 if (PyErr_Occurred()) SWIG_fail;
27737 }
27738 {
27739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27740 }
27741 return resultobj;
27742 fail:
27743 return NULL;
27744 }
27745
27746
27747 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27748 PyObject *resultobj = 0;
27749 wxPyApp *arg1 = (wxPyApp *) 0 ;
27750 bool arg2 ;
27751 void *argp1 = 0 ;
27752 int res1 = 0 ;
27753 bool val2 ;
27754 int ecode2 = 0 ;
27755 PyObject * obj0 = 0 ;
27756 PyObject * obj1 = 0 ;
27757 char * kwnames[] = {
27758 (char *) "self",(char *) "flag", NULL
27759 };
27760
27761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27763 if (!SWIG_IsOK(res1)) {
27764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27765 }
27766 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27768 if (!SWIG_IsOK(ecode2)) {
27769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27770 }
27771 arg2 = static_cast< bool >(val2);
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 (arg1)->SetUseBestVisual(arg2);
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 resultobj = SWIG_Py_Void();
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27786 PyObject *resultobj = 0;
27787 wxPyApp *arg1 = (wxPyApp *) 0 ;
27788 bool result;
27789 void *argp1 = 0 ;
27790 int res1 = 0 ;
27791 PyObject *swig_obj[1] ;
27792
27793 if (!args) SWIG_fail;
27794 swig_obj[0] = args;
27795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27796 if (!SWIG_IsOK(res1)) {
27797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27798 }
27799 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27803 wxPyEndAllowThreads(__tstate);
27804 if (PyErr_Occurred()) SWIG_fail;
27805 }
27806 {
27807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27808 }
27809 return resultobj;
27810 fail:
27811 return NULL;
27812 }
27813
27814
27815 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27816 PyObject *resultobj = 0;
27817 wxPyApp *arg1 = (wxPyApp *) 0 ;
27818 int arg2 ;
27819 void *argp1 = 0 ;
27820 int res1 = 0 ;
27821 int val2 ;
27822 int ecode2 = 0 ;
27823 PyObject * obj0 = 0 ;
27824 PyObject * obj1 = 0 ;
27825 char * kwnames[] = {
27826 (char *) "self",(char *) "mode", NULL
27827 };
27828
27829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27831 if (!SWIG_IsOK(res1)) {
27832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27833 }
27834 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27835 ecode2 = SWIG_AsVal_int(obj1, &val2);
27836 if (!SWIG_IsOK(ecode2)) {
27837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27838 }
27839 arg2 = static_cast< int >(val2);
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 (arg1)->SetPrintMode(arg2);
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 resultobj = SWIG_Py_Void();
27847 return resultobj;
27848 fail:
27849 return NULL;
27850 }
27851
27852
27853 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27854 PyObject *resultobj = 0;
27855 wxPyApp *arg1 = (wxPyApp *) 0 ;
27856 int result;
27857 void *argp1 = 0 ;
27858 int res1 = 0 ;
27859 PyObject *swig_obj[1] ;
27860
27861 if (!args) SWIG_fail;
27862 swig_obj[0] = args;
27863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27864 if (!SWIG_IsOK(res1)) {
27865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27866 }
27867 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 resultobj = SWIG_From_int(static_cast< int >(result));
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27882 PyObject *resultobj = 0;
27883 wxPyApp *arg1 = (wxPyApp *) 0 ;
27884 int arg2 ;
27885 void *argp1 = 0 ;
27886 int res1 = 0 ;
27887 int val2 ;
27888 int ecode2 = 0 ;
27889 PyObject * obj0 = 0 ;
27890 PyObject * obj1 = 0 ;
27891 char * kwnames[] = {
27892 (char *) "self",(char *) "mode", NULL
27893 };
27894
27895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27897 if (!SWIG_IsOK(res1)) {
27898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27899 }
27900 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27901 ecode2 = SWIG_AsVal_int(obj1, &val2);
27902 if (!SWIG_IsOK(ecode2)) {
27903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27904 }
27905 arg2 = static_cast< int >(val2);
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 (arg1)->SetAssertMode(arg2);
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 resultobj = SWIG_Py_Void();
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27920 PyObject *resultobj = 0;
27921 wxPyApp *arg1 = (wxPyApp *) 0 ;
27922 int result;
27923 void *argp1 = 0 ;
27924 int res1 = 0 ;
27925 PyObject *swig_obj[1] ;
27926
27927 if (!args) SWIG_fail;
27928 swig_obj[0] = args;
27929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27930 if (!SWIG_IsOK(res1)) {
27931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27932 }
27933 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27934 {
27935 PyThreadState* __tstate = wxPyBeginAllowThreads();
27936 result = (int)(arg1)->GetAssertMode();
27937 wxPyEndAllowThreads(__tstate);
27938 if (PyErr_Occurred()) SWIG_fail;
27939 }
27940 resultobj = SWIG_From_int(static_cast< int >(result));
27941 return resultobj;
27942 fail:
27943 return NULL;
27944 }
27945
27946
27947 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27948 PyObject *resultobj = 0;
27949 bool result;
27950
27951 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27952 {
27953 PyThreadState* __tstate = wxPyBeginAllowThreads();
27954 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 {
27959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27960 }
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27968 PyObject *resultobj = 0;
27969 long result;
27970
27971 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 result = (long)wxPyApp::GetMacAboutMenuItemId();
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 resultobj = SWIG_From_long(static_cast< long >(result));
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27986 PyObject *resultobj = 0;
27987 long result;
27988
27989 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27990 {
27991 PyThreadState* __tstate = wxPyBeginAllowThreads();
27992 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27993 wxPyEndAllowThreads(__tstate);
27994 if (PyErr_Occurred()) SWIG_fail;
27995 }
27996 resultobj = SWIG_From_long(static_cast< long >(result));
27997 return resultobj;
27998 fail:
27999 return NULL;
28000 }
28001
28002
28003 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28004 PyObject *resultobj = 0;
28005 long result;
28006
28007 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 result = (long)wxPyApp::GetMacExitMenuItemId();
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 resultobj = SWIG_From_long(static_cast< long >(result));
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28022 PyObject *resultobj = 0;
28023 wxString result;
28024
28025 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 result = wxPyApp::GetMacHelpMenuTitleName();
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 {
28033 #if wxUSE_UNICODE
28034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28035 #else
28036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28037 #endif
28038 }
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28046 PyObject *resultobj = 0;
28047 bool arg1 ;
28048 bool val1 ;
28049 int ecode1 = 0 ;
28050 PyObject * obj0 = 0 ;
28051 char * kwnames[] = {
28052 (char *) "val", NULL
28053 };
28054
28055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28056 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28057 if (!SWIG_IsOK(ecode1)) {
28058 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28059 }
28060 arg1 = static_cast< bool >(val1);
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28064 wxPyEndAllowThreads(__tstate);
28065 if (PyErr_Occurred()) SWIG_fail;
28066 }
28067 resultobj = SWIG_Py_Void();
28068 return resultobj;
28069 fail:
28070 return NULL;
28071 }
28072
28073
28074 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28075 PyObject *resultobj = 0;
28076 long arg1 ;
28077 long val1 ;
28078 int ecode1 = 0 ;
28079 PyObject * obj0 = 0 ;
28080 char * kwnames[] = {
28081 (char *) "val", NULL
28082 };
28083
28084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28085 ecode1 = SWIG_AsVal_long(obj0, &val1);
28086 if (!SWIG_IsOK(ecode1)) {
28087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28088 }
28089 arg1 = static_cast< long >(val1);
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 wxPyApp::SetMacAboutMenuItemId(arg1);
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 resultobj = SWIG_Py_Void();
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj = 0;
28105 long arg1 ;
28106 long val1 ;
28107 int ecode1 = 0 ;
28108 PyObject * obj0 = 0 ;
28109 char * kwnames[] = {
28110 (char *) "val", NULL
28111 };
28112
28113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28114 ecode1 = SWIG_AsVal_long(obj0, &val1);
28115 if (!SWIG_IsOK(ecode1)) {
28116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28117 }
28118 arg1 = static_cast< long >(val1);
28119 {
28120 PyThreadState* __tstate = wxPyBeginAllowThreads();
28121 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28122 wxPyEndAllowThreads(__tstate);
28123 if (PyErr_Occurred()) SWIG_fail;
28124 }
28125 resultobj = SWIG_Py_Void();
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 long arg1 ;
28135 long val1 ;
28136 int ecode1 = 0 ;
28137 PyObject * obj0 = 0 ;
28138 char * kwnames[] = {
28139 (char *) "val", NULL
28140 };
28141
28142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28143 ecode1 = SWIG_AsVal_long(obj0, &val1);
28144 if (!SWIG_IsOK(ecode1)) {
28145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28146 }
28147 arg1 = static_cast< long >(val1);
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 wxPyApp::SetMacExitMenuItemId(arg1);
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_Py_Void();
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj = 0;
28163 wxString *arg1 = 0 ;
28164 bool temp1 = false ;
28165 PyObject * obj0 = 0 ;
28166 char * kwnames[] = {
28167 (char *) "val", NULL
28168 };
28169
28170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28171 {
28172 arg1 = wxString_in_helper(obj0);
28173 if (arg1 == NULL) SWIG_fail;
28174 temp1 = true;
28175 }
28176 {
28177 PyThreadState* __tstate = wxPyBeginAllowThreads();
28178 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28179 wxPyEndAllowThreads(__tstate);
28180 if (PyErr_Occurred()) SWIG_fail;
28181 }
28182 resultobj = SWIG_Py_Void();
28183 {
28184 if (temp1)
28185 delete arg1;
28186 }
28187 return resultobj;
28188 fail:
28189 {
28190 if (temp1)
28191 delete arg1;
28192 }
28193 return NULL;
28194 }
28195
28196
28197 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28198 PyObject *resultobj = 0;
28199 wxPyApp *arg1 = (wxPyApp *) 0 ;
28200 void *argp1 = 0 ;
28201 int res1 = 0 ;
28202 PyObject *swig_obj[1] ;
28203
28204 if (!args) SWIG_fail;
28205 swig_obj[0] = args;
28206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28207 if (!SWIG_IsOK(res1)) {
28208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28209 }
28210 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 (arg1)->_BootstrapApp();
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 resultobj = SWIG_Py_Void();
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28225 PyObject *resultobj = 0;
28226 int result;
28227
28228 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 result = (int)wxPyApp::GetComCtl32Version();
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 resultobj = SWIG_From_int(static_cast< int >(result));
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28243 PyObject *obj;
28244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28245 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28246 return SWIG_Py_Void();
28247 }
28248
28249 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28250 return SWIG_Python_InitShadowInstance(args);
28251 }
28252
28253 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28254 PyObject *resultobj = 0;
28255
28256 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 wxExit();
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 resultobj = SWIG_Py_Void();
28264 return resultobj;
28265 fail:
28266 return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28271 PyObject *resultobj = 0;
28272 bool result;
28273
28274 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 result = (bool)wxYield();
28278 wxPyEndAllowThreads(__tstate);
28279 if (PyErr_Occurred()) SWIG_fail;
28280 }
28281 {
28282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28283 }
28284 return resultobj;
28285 fail:
28286 return NULL;
28287 }
28288
28289
28290 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28291 PyObject *resultobj = 0;
28292 bool result;
28293
28294 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 result = (bool)wxYieldIfNeeded();
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 {
28302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28303 }
28304 return resultobj;
28305 fail:
28306 return NULL;
28307 }
28308
28309
28310 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28311 PyObject *resultobj = 0;
28312 wxWindow *arg1 = (wxWindow *) NULL ;
28313 bool arg2 = (bool) false ;
28314 bool result;
28315 void *argp1 = 0 ;
28316 int res1 = 0 ;
28317 bool val2 ;
28318 int ecode2 = 0 ;
28319 PyObject * obj0 = 0 ;
28320 PyObject * obj1 = 0 ;
28321 char * kwnames[] = {
28322 (char *) "win",(char *) "onlyIfNeeded", NULL
28323 };
28324
28325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28326 if (obj0) {
28327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28328 if (!SWIG_IsOK(res1)) {
28329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28330 }
28331 arg1 = reinterpret_cast< wxWindow * >(argp1);
28332 }
28333 if (obj1) {
28334 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28335 if (!SWIG_IsOK(ecode2)) {
28336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28337 }
28338 arg2 = static_cast< bool >(val2);
28339 }
28340 {
28341 PyThreadState* __tstate = wxPyBeginAllowThreads();
28342 result = (bool)wxSafeYield(arg1,arg2);
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 {
28347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28348 }
28349 return resultobj;
28350 fail:
28351 return NULL;
28352 }
28353
28354
28355 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28356 PyObject *resultobj = 0;
28357
28358 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28359 {
28360 PyThreadState* __tstate = wxPyBeginAllowThreads();
28361 wxWakeUpIdle();
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 resultobj = SWIG_Py_Void();
28366 return resultobj;
28367 fail:
28368 return NULL;
28369 }
28370
28371
28372 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28373 PyObject *resultobj = 0;
28374 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28375 wxEvent *arg2 = 0 ;
28376 void *argp1 = 0 ;
28377 int res1 = 0 ;
28378 void *argp2 = 0 ;
28379 int res2 = 0 ;
28380 PyObject * obj0 = 0 ;
28381 PyObject * obj1 = 0 ;
28382 char * kwnames[] = {
28383 (char *) "dest",(char *) "event", NULL
28384 };
28385
28386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28388 if (!SWIG_IsOK(res1)) {
28389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28390 }
28391 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28392 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28393 if (!SWIG_IsOK(res2)) {
28394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28395 }
28396 if (!argp2) {
28397 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28398 }
28399 arg2 = reinterpret_cast< wxEvent * >(argp2);
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 wxPostEvent(arg1,*arg2);
28403 wxPyEndAllowThreads(__tstate);
28404 if (PyErr_Occurred()) SWIG_fail;
28405 }
28406 resultobj = SWIG_Py_Void();
28407 return resultobj;
28408 fail:
28409 return NULL;
28410 }
28411
28412
28413 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28414 PyObject *resultobj = 0;
28415
28416 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28417 {
28418 PyThreadState* __tstate = wxPyBeginAllowThreads();
28419 wxApp_CleanUp();
28420 wxPyEndAllowThreads(__tstate);
28421 if (PyErr_Occurred()) SWIG_fail;
28422 }
28423 resultobj = SWIG_Py_Void();
28424 return resultobj;
28425 fail:
28426 return NULL;
28427 }
28428
28429
28430 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28431 PyObject *resultobj = 0;
28432 wxPyApp *result = 0 ;
28433
28434 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28435 {
28436 PyThreadState* __tstate = wxPyBeginAllowThreads();
28437 result = (wxPyApp *)wxPyGetApp();
28438 wxPyEndAllowThreads(__tstate);
28439 if (PyErr_Occurred()) SWIG_fail;
28440 }
28441 {
28442 resultobj = wxPyMake_wxObject(result, 0);
28443 }
28444 return resultobj;
28445 fail:
28446 return NULL;
28447 }
28448
28449
28450 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28451 PyObject *resultobj = 0;
28452 char *arg1 = (char *) 0 ;
28453 int res1 ;
28454 char *buf1 = 0 ;
28455 int alloc1 = 0 ;
28456 PyObject * obj0 = 0 ;
28457 char * kwnames[] = {
28458 (char *) "encoding", NULL
28459 };
28460
28461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28462 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28463 if (!SWIG_IsOK(res1)) {
28464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28465 }
28466 arg1 = buf1;
28467 {
28468 PyThreadState* __tstate = wxPyBeginAllowThreads();
28469 wxSetDefaultPyEncoding((char const *)arg1);
28470 wxPyEndAllowThreads(__tstate);
28471 if (PyErr_Occurred()) SWIG_fail;
28472 }
28473 resultobj = SWIG_Py_Void();
28474 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28475 return resultobj;
28476 fail:
28477 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28478 return NULL;
28479 }
28480
28481
28482 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28483 PyObject *resultobj = 0;
28484 char *result = 0 ;
28485
28486 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28487 {
28488 PyThreadState* __tstate = wxPyBeginAllowThreads();
28489 result = (char *)wxGetDefaultPyEncoding();
28490 wxPyEndAllowThreads(__tstate);
28491 if (PyErr_Occurred()) SWIG_fail;
28492 }
28493 resultobj = SWIG_FromCharPtr(result);
28494 return resultobj;
28495 fail:
28496 return NULL;
28497 }
28498
28499
28500 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28501 PyObject *resultobj = 0;
28502 wxEventLoop *result = 0 ;
28503
28504 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (wxEventLoop *)new wxEventLoop();
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28512 return resultobj;
28513 fail:
28514 return NULL;
28515 }
28516
28517
28518 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28519 PyObject *resultobj = 0;
28520 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28521 void *argp1 = 0 ;
28522 int res1 = 0 ;
28523 PyObject *swig_obj[1] ;
28524
28525 if (!args) SWIG_fail;
28526 swig_obj[0] = args;
28527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28528 if (!SWIG_IsOK(res1)) {
28529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28530 }
28531 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 delete arg1;
28535
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 resultobj = SWIG_Py_Void();
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28547 PyObject *resultobj = 0;
28548 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28549 int result;
28550 void *argp1 = 0 ;
28551 int res1 = 0 ;
28552 PyObject *swig_obj[1] ;
28553
28554 if (!args) SWIG_fail;
28555 swig_obj[0] = args;
28556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28557 if (!SWIG_IsOK(res1)) {
28558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28559 }
28560 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28561 {
28562 PyThreadState* __tstate = wxPyBeginAllowThreads();
28563 result = (int)(arg1)->Run();
28564 wxPyEndAllowThreads(__tstate);
28565 if (PyErr_Occurred()) SWIG_fail;
28566 }
28567 resultobj = SWIG_From_int(static_cast< int >(result));
28568 return resultobj;
28569 fail:
28570 return NULL;
28571 }
28572
28573
28574 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28575 PyObject *resultobj = 0;
28576 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28577 int arg2 = (int) 0 ;
28578 void *argp1 = 0 ;
28579 int res1 = 0 ;
28580 int val2 ;
28581 int ecode2 = 0 ;
28582 PyObject * obj0 = 0 ;
28583 PyObject * obj1 = 0 ;
28584 char * kwnames[] = {
28585 (char *) "self",(char *) "rc", NULL
28586 };
28587
28588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28590 if (!SWIG_IsOK(res1)) {
28591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28592 }
28593 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28594 if (obj1) {
28595 ecode2 = SWIG_AsVal_int(obj1, &val2);
28596 if (!SWIG_IsOK(ecode2)) {
28597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28598 }
28599 arg2 = static_cast< int >(val2);
28600 }
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 (arg1)->Exit(arg2);
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 resultobj = SWIG_Py_Void();
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28615 PyObject *resultobj = 0;
28616 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28617 bool result;
28618 void *argp1 = 0 ;
28619 int res1 = 0 ;
28620 PyObject *swig_obj[1] ;
28621
28622 if (!args) SWIG_fail;
28623 swig_obj[0] = args;
28624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28625 if (!SWIG_IsOK(res1)) {
28626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28627 }
28628 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 result = (bool)((wxEventLoop const *)arg1)->Pending();
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 {
28636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28637 }
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *resultobj = 0;
28646 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28647 bool result;
28648 void *argp1 = 0 ;
28649 int res1 = 0 ;
28650 PyObject *swig_obj[1] ;
28651
28652 if (!args) SWIG_fail;
28653 swig_obj[0] = args;
28654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28655 if (!SWIG_IsOK(res1)) {
28656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28657 }
28658 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (bool)(arg1)->Dispatch();
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 {
28666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28667 }
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28675 PyObject *resultobj = 0;
28676 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28677 bool result;
28678 void *argp1 = 0 ;
28679 int res1 = 0 ;
28680 PyObject *swig_obj[1] ;
28681
28682 if (!args) SWIG_fail;
28683 swig_obj[0] = args;
28684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28685 if (!SWIG_IsOK(res1)) {
28686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28687 }
28688 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28689 {
28690 PyThreadState* __tstate = wxPyBeginAllowThreads();
28691 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28692 wxPyEndAllowThreads(__tstate);
28693 if (PyErr_Occurred()) SWIG_fail;
28694 }
28695 {
28696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28697 }
28698 return resultobj;
28699 fail:
28700 return NULL;
28701 }
28702
28703
28704 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28705 PyObject *resultobj = 0;
28706 wxEventLoop *result = 0 ;
28707
28708 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28709 {
28710 PyThreadState* __tstate = wxPyBeginAllowThreads();
28711 result = (wxEventLoop *)wxEventLoop::GetActive();
28712 wxPyEndAllowThreads(__tstate);
28713 if (PyErr_Occurred()) SWIG_fail;
28714 }
28715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28716 return resultobj;
28717 fail:
28718 return NULL;
28719 }
28720
28721
28722 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28723 PyObject *resultobj = 0;
28724 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28725 void *argp1 = 0 ;
28726 int res1 = 0 ;
28727 PyObject * obj0 = 0 ;
28728 char * kwnames[] = {
28729 (char *) "loop", NULL
28730 };
28731
28732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28734 if (!SWIG_IsOK(res1)) {
28735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28736 }
28737 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28738 {
28739 PyThreadState* __tstate = wxPyBeginAllowThreads();
28740 wxEventLoop::SetActive(arg1);
28741 wxPyEndAllowThreads(__tstate);
28742 if (PyErr_Occurred()) SWIG_fail;
28743 }
28744 resultobj = SWIG_Py_Void();
28745 return resultobj;
28746 fail:
28747 return NULL;
28748 }
28749
28750
28751 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28752 PyObject *obj;
28753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28754 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28755 return SWIG_Py_Void();
28756 }
28757
28758 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28759 return SWIG_Python_InitShadowInstance(args);
28760 }
28761
28762 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28763 PyObject *resultobj = 0;
28764 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28765 wxEventLoopActivator *result = 0 ;
28766 void *argp1 = 0 ;
28767 int res1 = 0 ;
28768 PyObject * obj0 = 0 ;
28769 char * kwnames[] = {
28770 (char *) "evtLoop", NULL
28771 };
28772
28773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28775 if (!SWIG_IsOK(res1)) {
28776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28777 }
28778 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28779 {
28780 PyThreadState* __tstate = wxPyBeginAllowThreads();
28781 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28786 return resultobj;
28787 fail:
28788 return NULL;
28789 }
28790
28791
28792 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28793 PyObject *resultobj = 0;
28794 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28795 void *argp1 = 0 ;
28796 int res1 = 0 ;
28797 PyObject *swig_obj[1] ;
28798
28799 if (!args) SWIG_fail;
28800 swig_obj[0] = args;
28801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28802 if (!SWIG_IsOK(res1)) {
28803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28804 }
28805 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 delete arg1;
28809
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 resultobj = SWIG_Py_Void();
28814 return resultobj;
28815 fail:
28816 return NULL;
28817 }
28818
28819
28820 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28821 PyObject *obj;
28822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28823 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28824 return SWIG_Py_Void();
28825 }
28826
28827 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28828 return SWIG_Python_InitShadowInstance(args);
28829 }
28830
28831 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28832 PyObject *resultobj = 0;
28833 int arg1 = (int) 0 ;
28834 int arg2 = (int) 0 ;
28835 int arg3 = (int) 0 ;
28836 wxAcceleratorEntry *result = 0 ;
28837 int val1 ;
28838 int ecode1 = 0 ;
28839 int val2 ;
28840 int ecode2 = 0 ;
28841 int val3 ;
28842 int ecode3 = 0 ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 PyObject * obj2 = 0 ;
28846 char * kwnames[] = {
28847 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28848 };
28849
28850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28851 if (obj0) {
28852 ecode1 = SWIG_AsVal_int(obj0, &val1);
28853 if (!SWIG_IsOK(ecode1)) {
28854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28855 }
28856 arg1 = static_cast< int >(val1);
28857 }
28858 if (obj1) {
28859 ecode2 = SWIG_AsVal_int(obj1, &val2);
28860 if (!SWIG_IsOK(ecode2)) {
28861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28862 }
28863 arg2 = static_cast< int >(val2);
28864 }
28865 if (obj2) {
28866 ecode3 = SWIG_AsVal_int(obj2, &val3);
28867 if (!SWIG_IsOK(ecode3)) {
28868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28869 }
28870 arg3 = static_cast< int >(val3);
28871 }
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28886 PyObject *resultobj = 0;
28887 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28888 void *argp1 = 0 ;
28889 int res1 = 0 ;
28890 PyObject *swig_obj[1] ;
28891
28892 if (!args) SWIG_fail;
28893 swig_obj[0] = args;
28894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28895 if (!SWIG_IsOK(res1)) {
28896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28897 }
28898 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 delete arg1;
28902
28903 wxPyEndAllowThreads(__tstate);
28904 if (PyErr_Occurred()) SWIG_fail;
28905 }
28906 resultobj = SWIG_Py_Void();
28907 return resultobj;
28908 fail:
28909 return NULL;
28910 }
28911
28912
28913 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28914 PyObject *resultobj = 0;
28915 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28916 int arg2 ;
28917 int arg3 ;
28918 int arg4 ;
28919 void *argp1 = 0 ;
28920 int res1 = 0 ;
28921 int val2 ;
28922 int ecode2 = 0 ;
28923 int val3 ;
28924 int ecode3 = 0 ;
28925 int val4 ;
28926 int ecode4 = 0 ;
28927 PyObject * obj0 = 0 ;
28928 PyObject * obj1 = 0 ;
28929 PyObject * obj2 = 0 ;
28930 PyObject * obj3 = 0 ;
28931 char * kwnames[] = {
28932 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28933 };
28934
28935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28937 if (!SWIG_IsOK(res1)) {
28938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28939 }
28940 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28941 ecode2 = SWIG_AsVal_int(obj1, &val2);
28942 if (!SWIG_IsOK(ecode2)) {
28943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28944 }
28945 arg2 = static_cast< int >(val2);
28946 ecode3 = SWIG_AsVal_int(obj2, &val3);
28947 if (!SWIG_IsOK(ecode3)) {
28948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28949 }
28950 arg3 = static_cast< int >(val3);
28951 ecode4 = SWIG_AsVal_int(obj3, &val4);
28952 if (!SWIG_IsOK(ecode4)) {
28953 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28954 }
28955 arg4 = static_cast< int >(val4);
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 (arg1)->Set(arg2,arg3,arg4);
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_Py_Void();
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *resultobj = 0;
28971 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28972 int result;
28973 void *argp1 = 0 ;
28974 int res1 = 0 ;
28975 PyObject *swig_obj[1] ;
28976
28977 if (!args) SWIG_fail;
28978 swig_obj[0] = args;
28979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28980 if (!SWIG_IsOK(res1)) {
28981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28982 }
28983 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (int)(arg1)->GetFlags();
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_From_int(static_cast< int >(result));
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29000 int result;
29001 void *argp1 = 0 ;
29002 int res1 = 0 ;
29003 PyObject *swig_obj[1] ;
29004
29005 if (!args) SWIG_fail;
29006 swig_obj[0] = args;
29007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29008 if (!SWIG_IsOK(res1)) {
29009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29010 }
29011 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (int)(arg1)->GetKeyCode();
29015 wxPyEndAllowThreads(__tstate);
29016 if (PyErr_Occurred()) SWIG_fail;
29017 }
29018 resultobj = SWIG_From_int(static_cast< int >(result));
29019 return resultobj;
29020 fail:
29021 return NULL;
29022 }
29023
29024
29025 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29026 PyObject *resultobj = 0;
29027 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29028 int result;
29029 void *argp1 = 0 ;
29030 int res1 = 0 ;
29031 PyObject *swig_obj[1] ;
29032
29033 if (!args) SWIG_fail;
29034 swig_obj[0] = args;
29035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29036 if (!SWIG_IsOK(res1)) {
29037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29038 }
29039 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29040 {
29041 PyThreadState* __tstate = wxPyBeginAllowThreads();
29042 result = (int)(arg1)->GetCommand();
29043 wxPyEndAllowThreads(__tstate);
29044 if (PyErr_Occurred()) SWIG_fail;
29045 }
29046 resultobj = SWIG_From_int(static_cast< int >(result));
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29054 PyObject *obj;
29055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29056 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29057 return SWIG_Py_Void();
29058 }
29059
29060 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29061 return SWIG_Python_InitShadowInstance(args);
29062 }
29063
29064 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj = 0;
29066 int arg1 ;
29067 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29068 wxAcceleratorTable *result = 0 ;
29069 PyObject * obj0 = 0 ;
29070 char * kwnames[] = {
29071 (char *) "n", NULL
29072 };
29073
29074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29075 {
29076 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29077 if (arg2) arg1 = PyList_Size(obj0);
29078 else arg1 = 0;
29079 }
29080 {
29081 PyThreadState* __tstate = wxPyBeginAllowThreads();
29082 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29094 PyObject *resultobj = 0;
29095 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29096 void *argp1 = 0 ;
29097 int res1 = 0 ;
29098 PyObject *swig_obj[1] ;
29099
29100 if (!args) SWIG_fail;
29101 swig_obj[0] = args;
29102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29103 if (!SWIG_IsOK(res1)) {
29104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29105 }
29106 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 delete arg1;
29110
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 resultobj = SWIG_Py_Void();
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29122 PyObject *resultobj = 0;
29123 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29124 bool result;
29125 void *argp1 = 0 ;
29126 int res1 = 0 ;
29127 PyObject *swig_obj[1] ;
29128
29129 if (!args) SWIG_fail;
29130 swig_obj[0] = args;
29131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29132 if (!SWIG_IsOK(res1)) {
29133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29134 }
29135 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29139 wxPyEndAllowThreads(__tstate);
29140 if (PyErr_Occurred()) SWIG_fail;
29141 }
29142 {
29143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29144 }
29145 return resultobj;
29146 fail:
29147 return NULL;
29148 }
29149
29150
29151 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29152 PyObject *obj;
29153 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29154 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29155 return SWIG_Py_Void();
29156 }
29157
29158 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29159 return SWIG_Python_InitShadowInstance(args);
29160 }
29161
29162 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29163 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29164 return 1;
29165 }
29166
29167
29168 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29169 PyObject *pyobj = 0;
29170
29171 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29172 return pyobj;
29173 }
29174
29175
29176 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29177 PyObject *resultobj = 0;
29178 wxString *arg1 = 0 ;
29179 wxAcceleratorEntry *result = 0 ;
29180 bool temp1 = false ;
29181 PyObject * obj0 = 0 ;
29182 char * kwnames[] = {
29183 (char *) "label", NULL
29184 };
29185
29186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29187 {
29188 arg1 = wxString_in_helper(obj0);
29189 if (arg1 == NULL) SWIG_fail;
29190 temp1 = true;
29191 }
29192 {
29193 PyThreadState* __tstate = wxPyBeginAllowThreads();
29194 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29195 wxPyEndAllowThreads(__tstate);
29196 if (PyErr_Occurred()) SWIG_fail;
29197 }
29198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29199 {
29200 if (temp1)
29201 delete arg1;
29202 }
29203 return resultobj;
29204 fail:
29205 {
29206 if (temp1)
29207 delete arg1;
29208 }
29209 return NULL;
29210 }
29211
29212
29213 SWIGINTERN int PanelNameStr_set(PyObject *) {
29214 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29215 return 1;
29216 }
29217
29218
29219 SWIGINTERN PyObject *PanelNameStr_get(void) {
29220 PyObject *pyobj = 0;
29221
29222 {
29223 #if wxUSE_UNICODE
29224 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29225 #else
29226 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29227 #endif
29228 }
29229 return pyobj;
29230 }
29231
29232
29233 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29234 PyObject *resultobj = 0;
29235 wxVisualAttributes *result = 0 ;
29236
29237 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29238 {
29239 PyThreadState* __tstate = wxPyBeginAllowThreads();
29240 result = (wxVisualAttributes *)new_wxVisualAttributes();
29241 wxPyEndAllowThreads(__tstate);
29242 if (PyErr_Occurred()) SWIG_fail;
29243 }
29244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29252 PyObject *resultobj = 0;
29253 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29254 void *argp1 = 0 ;
29255 int res1 = 0 ;
29256 PyObject *swig_obj[1] ;
29257
29258 if (!args) SWIG_fail;
29259 swig_obj[0] = args;
29260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29261 if (!SWIG_IsOK(res1)) {
29262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29263 }
29264 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 delete_wxVisualAttributes(arg1);
29268
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 resultobj = SWIG_Py_Void();
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 PyObject *resultobj = 0;
29281 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29282 wxFont *arg2 = (wxFont *) 0 ;
29283 void *argp1 = 0 ;
29284 int res1 = 0 ;
29285 void *argp2 = 0 ;
29286 int res2 = 0 ;
29287 PyObject *swig_obj[2] ;
29288
29289 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29291 if (!SWIG_IsOK(res1)) {
29292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29293 }
29294 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29295 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29296 if (!SWIG_IsOK(res2)) {
29297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29298 }
29299 arg2 = reinterpret_cast< wxFont * >(argp2);
29300 if (arg1) (arg1)->font = *arg2;
29301
29302 resultobj = SWIG_Py_Void();
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29310 PyObject *resultobj = 0;
29311 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29312 wxFont *result = 0 ;
29313 void *argp1 = 0 ;
29314 int res1 = 0 ;
29315 PyObject *swig_obj[1] ;
29316
29317 if (!args) SWIG_fail;
29318 swig_obj[0] = args;
29319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29320 if (!SWIG_IsOK(res1)) {
29321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29322 }
29323 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29324 result = (wxFont *)& ((arg1)->font);
29325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29326 return resultobj;
29327 fail:
29328 return NULL;
29329 }
29330
29331
29332 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29333 PyObject *resultobj = 0;
29334 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29335 wxColour *arg2 = (wxColour *) 0 ;
29336 void *argp1 = 0 ;
29337 int res1 = 0 ;
29338 void *argp2 = 0 ;
29339 int res2 = 0 ;
29340 PyObject *swig_obj[2] ;
29341
29342 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29344 if (!SWIG_IsOK(res1)) {
29345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29346 }
29347 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29348 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29349 if (!SWIG_IsOK(res2)) {
29350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29351 }
29352 arg2 = reinterpret_cast< wxColour * >(argp2);
29353 if (arg1) (arg1)->colFg = *arg2;
29354
29355 resultobj = SWIG_Py_Void();
29356 return resultobj;
29357 fail:
29358 return NULL;
29359 }
29360
29361
29362 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29363 PyObject *resultobj = 0;
29364 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29365 wxColour *result = 0 ;
29366 void *argp1 = 0 ;
29367 int res1 = 0 ;
29368 PyObject *swig_obj[1] ;
29369
29370 if (!args) SWIG_fail;
29371 swig_obj[0] = args;
29372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29373 if (!SWIG_IsOK(res1)) {
29374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29375 }
29376 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29377 result = (wxColour *)& ((arg1)->colFg);
29378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29379 return resultobj;
29380 fail:
29381 return NULL;
29382 }
29383
29384
29385 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29386 PyObject *resultobj = 0;
29387 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29388 wxColour *arg2 = (wxColour *) 0 ;
29389 void *argp1 = 0 ;
29390 int res1 = 0 ;
29391 void *argp2 = 0 ;
29392 int res2 = 0 ;
29393 PyObject *swig_obj[2] ;
29394
29395 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29397 if (!SWIG_IsOK(res1)) {
29398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29399 }
29400 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29401 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29402 if (!SWIG_IsOK(res2)) {
29403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29404 }
29405 arg2 = reinterpret_cast< wxColour * >(argp2);
29406 if (arg1) (arg1)->colBg = *arg2;
29407
29408 resultobj = SWIG_Py_Void();
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 PyObject *resultobj = 0;
29417 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29418 wxColour *result = 0 ;
29419 void *argp1 = 0 ;
29420 int res1 = 0 ;
29421 PyObject *swig_obj[1] ;
29422
29423 if (!args) SWIG_fail;
29424 swig_obj[0] = args;
29425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29428 }
29429 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29430 result = (wxColour *)& ((arg1)->colBg);
29431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29432 return resultobj;
29433 fail:
29434 return NULL;
29435 }
29436
29437
29438 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29439 PyObject *obj;
29440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29441 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29442 return SWIG_Py_Void();
29443 }
29444
29445 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29446 return SWIG_Python_InitShadowInstance(args);
29447 }
29448
29449 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29450 PyObject *resultobj = 0;
29451 wxWindow *arg1 = (wxWindow *) 0 ;
29452 int arg2 = (int) (int)-1 ;
29453 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29454 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29455 wxSize const &arg4_defvalue = wxDefaultSize ;
29456 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29457 long arg5 = (long) 0 ;
29458 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29459 wxString *arg6 = (wxString *) &arg6_defvalue ;
29460 wxWindow *result = 0 ;
29461 void *argp1 = 0 ;
29462 int res1 = 0 ;
29463 int val2 ;
29464 int ecode2 = 0 ;
29465 wxPoint temp3 ;
29466 wxSize temp4 ;
29467 long val5 ;
29468 int ecode5 = 0 ;
29469 bool temp6 = false ;
29470 PyObject * obj0 = 0 ;
29471 PyObject * obj1 = 0 ;
29472 PyObject * obj2 = 0 ;
29473 PyObject * obj3 = 0 ;
29474 PyObject * obj4 = 0 ;
29475 PyObject * obj5 = 0 ;
29476 char * kwnames[] = {
29477 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29478 };
29479
29480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29482 if (!SWIG_IsOK(res1)) {
29483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29484 }
29485 arg1 = reinterpret_cast< wxWindow * >(argp1);
29486 if (obj1) {
29487 ecode2 = SWIG_AsVal_int(obj1, &val2);
29488 if (!SWIG_IsOK(ecode2)) {
29489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29490 }
29491 arg2 = static_cast< int >(val2);
29492 }
29493 if (obj2) {
29494 {
29495 arg3 = &temp3;
29496 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29497 }
29498 }
29499 if (obj3) {
29500 {
29501 arg4 = &temp4;
29502 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29503 }
29504 }
29505 if (obj4) {
29506 ecode5 = SWIG_AsVal_long(obj4, &val5);
29507 if (!SWIG_IsOK(ecode5)) {
29508 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29509 }
29510 arg5 = static_cast< long >(val5);
29511 }
29512 if (obj5) {
29513 {
29514 arg6 = wxString_in_helper(obj5);
29515 if (arg6 == NULL) SWIG_fail;
29516 temp6 = true;
29517 }
29518 }
29519 {
29520 if (!wxPyCheckForApp()) SWIG_fail;
29521 PyThreadState* __tstate = wxPyBeginAllowThreads();
29522 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29523 wxPyEndAllowThreads(__tstate);
29524 if (PyErr_Occurred()) SWIG_fail;
29525 }
29526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29527 {
29528 if (temp6)
29529 delete arg6;
29530 }
29531 return resultobj;
29532 fail:
29533 {
29534 if (temp6)
29535 delete arg6;
29536 }
29537 return NULL;
29538 }
29539
29540
29541 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29542 PyObject *resultobj = 0;
29543 wxWindow *result = 0 ;
29544
29545 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29546 {
29547 if (!wxPyCheckForApp()) SWIG_fail;
29548 PyThreadState* __tstate = wxPyBeginAllowThreads();
29549 result = (wxWindow *)new wxWindow();
29550 wxPyEndAllowThreads(__tstate);
29551 if (PyErr_Occurred()) SWIG_fail;
29552 }
29553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29554 return resultobj;
29555 fail:
29556 return NULL;
29557 }
29558
29559
29560 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29561 PyObject *resultobj = 0;
29562 wxWindow *arg1 = (wxWindow *) 0 ;
29563 wxWindow *arg2 = (wxWindow *) 0 ;
29564 int arg3 = (int) (int)-1 ;
29565 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29566 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29567 wxSize const &arg5_defvalue = wxDefaultSize ;
29568 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29569 long arg6 = (long) 0 ;
29570 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29571 wxString *arg7 = (wxString *) &arg7_defvalue ;
29572 bool result;
29573 void *argp1 = 0 ;
29574 int res1 = 0 ;
29575 void *argp2 = 0 ;
29576 int res2 = 0 ;
29577 int val3 ;
29578 int ecode3 = 0 ;
29579 wxPoint temp4 ;
29580 wxSize temp5 ;
29581 long val6 ;
29582 int ecode6 = 0 ;
29583 bool temp7 = false ;
29584 PyObject * obj0 = 0 ;
29585 PyObject * obj1 = 0 ;
29586 PyObject * obj2 = 0 ;
29587 PyObject * obj3 = 0 ;
29588 PyObject * obj4 = 0 ;
29589 PyObject * obj5 = 0 ;
29590 PyObject * obj6 = 0 ;
29591 char * kwnames[] = {
29592 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29593 };
29594
29595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29597 if (!SWIG_IsOK(res1)) {
29598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29599 }
29600 arg1 = reinterpret_cast< wxWindow * >(argp1);
29601 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29602 if (!SWIG_IsOK(res2)) {
29603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29604 }
29605 arg2 = reinterpret_cast< wxWindow * >(argp2);
29606 if (obj2) {
29607 ecode3 = SWIG_AsVal_int(obj2, &val3);
29608 if (!SWIG_IsOK(ecode3)) {
29609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29610 }
29611 arg3 = static_cast< int >(val3);
29612 }
29613 if (obj3) {
29614 {
29615 arg4 = &temp4;
29616 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29617 }
29618 }
29619 if (obj4) {
29620 {
29621 arg5 = &temp5;
29622 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29623 }
29624 }
29625 if (obj5) {
29626 ecode6 = SWIG_AsVal_long(obj5, &val6);
29627 if (!SWIG_IsOK(ecode6)) {
29628 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29629 }
29630 arg6 = static_cast< long >(val6);
29631 }
29632 if (obj6) {
29633 {
29634 arg7 = wxString_in_helper(obj6);
29635 if (arg7 == NULL) SWIG_fail;
29636 temp7 = true;
29637 }
29638 }
29639 {
29640 PyThreadState* __tstate = wxPyBeginAllowThreads();
29641 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29642 wxPyEndAllowThreads(__tstate);
29643 if (PyErr_Occurred()) SWIG_fail;
29644 }
29645 {
29646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29647 }
29648 {
29649 if (temp7)
29650 delete arg7;
29651 }
29652 return resultobj;
29653 fail:
29654 {
29655 if (temp7)
29656 delete arg7;
29657 }
29658 return NULL;
29659 }
29660
29661
29662 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29663 PyObject *resultobj = 0;
29664 wxWindow *arg1 = (wxWindow *) 0 ;
29665 bool arg2 = (bool) false ;
29666 bool result;
29667 void *argp1 = 0 ;
29668 int res1 = 0 ;
29669 bool val2 ;
29670 int ecode2 = 0 ;
29671 PyObject * obj0 = 0 ;
29672 PyObject * obj1 = 0 ;
29673 char * kwnames[] = {
29674 (char *) "self",(char *) "force", NULL
29675 };
29676
29677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29679 if (!SWIG_IsOK(res1)) {
29680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29681 }
29682 arg1 = reinterpret_cast< wxWindow * >(argp1);
29683 if (obj1) {
29684 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29685 if (!SWIG_IsOK(ecode2)) {
29686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29687 }
29688 arg2 = static_cast< bool >(val2);
29689 }
29690 {
29691 PyThreadState* __tstate = wxPyBeginAllowThreads();
29692 result = (bool)(arg1)->Close(arg2);
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 {
29697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29698 }
29699 return resultobj;
29700 fail:
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29706 PyObject *resultobj = 0;
29707 wxWindow *arg1 = (wxWindow *) 0 ;
29708 bool result;
29709 void *argp1 = 0 ;
29710 int res1 = 0 ;
29711 PyObject *swig_obj[1] ;
29712
29713 if (!args) SWIG_fail;
29714 swig_obj[0] = args;
29715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29716 if (!SWIG_IsOK(res1)) {
29717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29718 }
29719 arg1 = reinterpret_cast< wxWindow * >(argp1);
29720 {
29721 PyThreadState* __tstate = wxPyBeginAllowThreads();
29722 result = (bool)(arg1)->Destroy();
29723 wxPyEndAllowThreads(__tstate);
29724 if (PyErr_Occurred()) SWIG_fail;
29725 }
29726 {
29727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29728 }
29729 return resultobj;
29730 fail:
29731 return NULL;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29736 PyObject *resultobj = 0;
29737 wxWindow *arg1 = (wxWindow *) 0 ;
29738 bool result;
29739 void *argp1 = 0 ;
29740 int res1 = 0 ;
29741 PyObject *swig_obj[1] ;
29742
29743 if (!args) SWIG_fail;
29744 swig_obj[0] = args;
29745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29746 if (!SWIG_IsOK(res1)) {
29747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29748 }
29749 arg1 = reinterpret_cast< wxWindow * >(argp1);
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (bool)(arg1)->DestroyChildren();
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 {
29757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29758 }
29759 return resultobj;
29760 fail:
29761 return NULL;
29762 }
29763
29764
29765 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29766 PyObject *resultobj = 0;
29767 wxWindow *arg1 = (wxWindow *) 0 ;
29768 bool result;
29769 void *argp1 = 0 ;
29770 int res1 = 0 ;
29771 PyObject *swig_obj[1] ;
29772
29773 if (!args) SWIG_fail;
29774 swig_obj[0] = args;
29775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29776 if (!SWIG_IsOK(res1)) {
29777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29778 }
29779 arg1 = reinterpret_cast< wxWindow * >(argp1);
29780 {
29781 PyThreadState* __tstate = wxPyBeginAllowThreads();
29782 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29783 wxPyEndAllowThreads(__tstate);
29784 if (PyErr_Occurred()) SWIG_fail;
29785 }
29786 {
29787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29788 }
29789 return resultobj;
29790 fail:
29791 return NULL;
29792 }
29793
29794
29795 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29796 PyObject *resultobj = 0;
29797 wxWindow *arg1 = (wxWindow *) 0 ;
29798 wxString *arg2 = 0 ;
29799 void *argp1 = 0 ;
29800 int res1 = 0 ;
29801 bool temp2 = false ;
29802 PyObject * obj0 = 0 ;
29803 PyObject * obj1 = 0 ;
29804 char * kwnames[] = {
29805 (char *) "self",(char *) "label", NULL
29806 };
29807
29808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29810 if (!SWIG_IsOK(res1)) {
29811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29812 }
29813 arg1 = reinterpret_cast< wxWindow * >(argp1);
29814 {
29815 arg2 = wxString_in_helper(obj1);
29816 if (arg2 == NULL) SWIG_fail;
29817 temp2 = true;
29818 }
29819 {
29820 PyThreadState* __tstate = wxPyBeginAllowThreads();
29821 (arg1)->SetLabel((wxString const &)*arg2);
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 resultobj = SWIG_Py_Void();
29826 {
29827 if (temp2)
29828 delete arg2;
29829 }
29830 return resultobj;
29831 fail:
29832 {
29833 if (temp2)
29834 delete arg2;
29835 }
29836 return NULL;
29837 }
29838
29839
29840 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29841 PyObject *resultobj = 0;
29842 wxWindow *arg1 = (wxWindow *) 0 ;
29843 wxString result;
29844 void *argp1 = 0 ;
29845 int res1 = 0 ;
29846 PyObject *swig_obj[1] ;
29847
29848 if (!args) SWIG_fail;
29849 swig_obj[0] = args;
29850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29851 if (!SWIG_IsOK(res1)) {
29852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29853 }
29854 arg1 = reinterpret_cast< wxWindow * >(argp1);
29855 {
29856 PyThreadState* __tstate = wxPyBeginAllowThreads();
29857 result = ((wxWindow const *)arg1)->GetLabel();
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 {
29862 #if wxUSE_UNICODE
29863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29864 #else
29865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29866 #endif
29867 }
29868 return resultobj;
29869 fail:
29870 return NULL;
29871 }
29872
29873
29874 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29875 PyObject *resultobj = 0;
29876 wxWindow *arg1 = (wxWindow *) 0 ;
29877 wxString *arg2 = 0 ;
29878 void *argp1 = 0 ;
29879 int res1 = 0 ;
29880 bool temp2 = false ;
29881 PyObject * obj0 = 0 ;
29882 PyObject * obj1 = 0 ;
29883 char * kwnames[] = {
29884 (char *) "self",(char *) "name", NULL
29885 };
29886
29887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29889 if (!SWIG_IsOK(res1)) {
29890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29891 }
29892 arg1 = reinterpret_cast< wxWindow * >(argp1);
29893 {
29894 arg2 = wxString_in_helper(obj1);
29895 if (arg2 == NULL) SWIG_fail;
29896 temp2 = true;
29897 }
29898 {
29899 PyThreadState* __tstate = wxPyBeginAllowThreads();
29900 (arg1)->SetName((wxString const &)*arg2);
29901 wxPyEndAllowThreads(__tstate);
29902 if (PyErr_Occurred()) SWIG_fail;
29903 }
29904 resultobj = SWIG_Py_Void();
29905 {
29906 if (temp2)
29907 delete arg2;
29908 }
29909 return resultobj;
29910 fail:
29911 {
29912 if (temp2)
29913 delete arg2;
29914 }
29915 return NULL;
29916 }
29917
29918
29919 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29920 PyObject *resultobj = 0;
29921 wxWindow *arg1 = (wxWindow *) 0 ;
29922 wxString result;
29923 void *argp1 = 0 ;
29924 int res1 = 0 ;
29925 PyObject *swig_obj[1] ;
29926
29927 if (!args) SWIG_fail;
29928 swig_obj[0] = args;
29929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29930 if (!SWIG_IsOK(res1)) {
29931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29932 }
29933 arg1 = reinterpret_cast< wxWindow * >(argp1);
29934 {
29935 PyThreadState* __tstate = wxPyBeginAllowThreads();
29936 result = ((wxWindow const *)arg1)->GetName();
29937 wxPyEndAllowThreads(__tstate);
29938 if (PyErr_Occurred()) SWIG_fail;
29939 }
29940 {
29941 #if wxUSE_UNICODE
29942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29943 #else
29944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29945 #endif
29946 }
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj = 0;
29955 wxWindow *arg1 = (wxWindow *) 0 ;
29956 wxWindowVariant arg2 ;
29957 void *argp1 = 0 ;
29958 int res1 = 0 ;
29959 int val2 ;
29960 int ecode2 = 0 ;
29961 PyObject * obj0 = 0 ;
29962 PyObject * obj1 = 0 ;
29963 char * kwnames[] = {
29964 (char *) "self",(char *) "variant", NULL
29965 };
29966
29967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29969 if (!SWIG_IsOK(res1)) {
29970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29971 }
29972 arg1 = reinterpret_cast< wxWindow * >(argp1);
29973 ecode2 = SWIG_AsVal_int(obj1, &val2);
29974 if (!SWIG_IsOK(ecode2)) {
29975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29976 }
29977 arg2 = static_cast< wxWindowVariant >(val2);
29978 {
29979 PyThreadState* __tstate = wxPyBeginAllowThreads();
29980 (arg1)->SetWindowVariant(arg2);
29981 wxPyEndAllowThreads(__tstate);
29982 if (PyErr_Occurred()) SWIG_fail;
29983 }
29984 resultobj = SWIG_Py_Void();
29985 return resultobj;
29986 fail:
29987 return NULL;
29988 }
29989
29990
29991 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29992 PyObject *resultobj = 0;
29993 wxWindow *arg1 = (wxWindow *) 0 ;
29994 wxWindowVariant result;
29995 void *argp1 = 0 ;
29996 int res1 = 0 ;
29997 PyObject *swig_obj[1] ;
29998
29999 if (!args) SWIG_fail;
30000 swig_obj[0] = args;
30001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30002 if (!SWIG_IsOK(res1)) {
30003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30004 }
30005 arg1 = reinterpret_cast< wxWindow * >(argp1);
30006 {
30007 PyThreadState* __tstate = wxPyBeginAllowThreads();
30008 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30009 wxPyEndAllowThreads(__tstate);
30010 if (PyErr_Occurred()) SWIG_fail;
30011 }
30012 resultobj = SWIG_From_int(static_cast< int >(result));
30013 return resultobj;
30014 fail:
30015 return NULL;
30016 }
30017
30018
30019 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj = 0;
30021 wxWindow *arg1 = (wxWindow *) 0 ;
30022 int arg2 ;
30023 void *argp1 = 0 ;
30024 int res1 = 0 ;
30025 int val2 ;
30026 int ecode2 = 0 ;
30027 PyObject * obj0 = 0 ;
30028 PyObject * obj1 = 0 ;
30029 char * kwnames[] = {
30030 (char *) "self",(char *) "winid", NULL
30031 };
30032
30033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30035 if (!SWIG_IsOK(res1)) {
30036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30037 }
30038 arg1 = reinterpret_cast< wxWindow * >(argp1);
30039 ecode2 = SWIG_AsVal_int(obj1, &val2);
30040 if (!SWIG_IsOK(ecode2)) {
30041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30042 }
30043 arg2 = static_cast< int >(val2);
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 (arg1)->SetId(arg2);
30047 wxPyEndAllowThreads(__tstate);
30048 if (PyErr_Occurred()) SWIG_fail;
30049 }
30050 resultobj = SWIG_Py_Void();
30051 return resultobj;
30052 fail:
30053 return NULL;
30054 }
30055
30056
30057 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30058 PyObject *resultobj = 0;
30059 wxWindow *arg1 = (wxWindow *) 0 ;
30060 int result;
30061 void *argp1 = 0 ;
30062 int res1 = 0 ;
30063 PyObject *swig_obj[1] ;
30064
30065 if (!args) SWIG_fail;
30066 swig_obj[0] = args;
30067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30068 if (!SWIG_IsOK(res1)) {
30069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30070 }
30071 arg1 = reinterpret_cast< wxWindow * >(argp1);
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 result = (int)((wxWindow const *)arg1)->GetId();
30075 wxPyEndAllowThreads(__tstate);
30076 if (PyErr_Occurred()) SWIG_fail;
30077 }
30078 resultobj = SWIG_From_int(static_cast< int >(result));
30079 return resultobj;
30080 fail:
30081 return NULL;
30082 }
30083
30084
30085 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30086 PyObject *resultobj = 0;
30087 int result;
30088
30089 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 result = (int)wxWindow::NewControlId();
30093 wxPyEndAllowThreads(__tstate);
30094 if (PyErr_Occurred()) SWIG_fail;
30095 }
30096 resultobj = SWIG_From_int(static_cast< int >(result));
30097 return resultobj;
30098 fail:
30099 return NULL;
30100 }
30101
30102
30103 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30104 PyObject *resultobj = 0;
30105 int arg1 ;
30106 int result;
30107 int val1 ;
30108 int ecode1 = 0 ;
30109 PyObject * obj0 = 0 ;
30110 char * kwnames[] = {
30111 (char *) "winid", NULL
30112 };
30113
30114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30115 ecode1 = SWIG_AsVal_int(obj0, &val1);
30116 if (!SWIG_IsOK(ecode1)) {
30117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30118 }
30119 arg1 = static_cast< int >(val1);
30120 {
30121 PyThreadState* __tstate = wxPyBeginAllowThreads();
30122 result = (int)wxWindow::NextControlId(arg1);
30123 wxPyEndAllowThreads(__tstate);
30124 if (PyErr_Occurred()) SWIG_fail;
30125 }
30126 resultobj = SWIG_From_int(static_cast< int >(result));
30127 return resultobj;
30128 fail:
30129 return NULL;
30130 }
30131
30132
30133 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30134 PyObject *resultobj = 0;
30135 int arg1 ;
30136 int result;
30137 int val1 ;
30138 int ecode1 = 0 ;
30139 PyObject * obj0 = 0 ;
30140 char * kwnames[] = {
30141 (char *) "winid", NULL
30142 };
30143
30144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30145 ecode1 = SWIG_AsVal_int(obj0, &val1);
30146 if (!SWIG_IsOK(ecode1)) {
30147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30148 }
30149 arg1 = static_cast< int >(val1);
30150 {
30151 PyThreadState* __tstate = wxPyBeginAllowThreads();
30152 result = (int)wxWindow::PrevControlId(arg1);
30153 wxPyEndAllowThreads(__tstate);
30154 if (PyErr_Occurred()) SWIG_fail;
30155 }
30156 resultobj = SWIG_From_int(static_cast< int >(result));
30157 return resultobj;
30158 fail:
30159 return NULL;
30160 }
30161
30162
30163 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30164 PyObject *resultobj = 0;
30165 wxWindow *arg1 = (wxWindow *) 0 ;
30166 wxSize *arg2 = 0 ;
30167 void *argp1 = 0 ;
30168 int res1 = 0 ;
30169 wxSize temp2 ;
30170 PyObject * obj0 = 0 ;
30171 PyObject * obj1 = 0 ;
30172 char * kwnames[] = {
30173 (char *) "self",(char *) "size", NULL
30174 };
30175
30176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30178 if (!SWIG_IsOK(res1)) {
30179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30180 }
30181 arg1 = reinterpret_cast< wxWindow * >(argp1);
30182 {
30183 arg2 = &temp2;
30184 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30185 }
30186 {
30187 PyThreadState* __tstate = wxPyBeginAllowThreads();
30188 (arg1)->SetSize((wxSize const &)*arg2);
30189 wxPyEndAllowThreads(__tstate);
30190 if (PyErr_Occurred()) SWIG_fail;
30191 }
30192 resultobj = SWIG_Py_Void();
30193 return resultobj;
30194 fail:
30195 return NULL;
30196 }
30197
30198
30199 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30200 PyObject *resultobj = 0;
30201 wxWindow *arg1 = (wxWindow *) 0 ;
30202 int arg2 ;
30203 int arg3 ;
30204 int arg4 ;
30205 int arg5 ;
30206 int arg6 = (int) wxSIZE_AUTO ;
30207 void *argp1 = 0 ;
30208 int res1 = 0 ;
30209 int val2 ;
30210 int ecode2 = 0 ;
30211 int val3 ;
30212 int ecode3 = 0 ;
30213 int val4 ;
30214 int ecode4 = 0 ;
30215 int val5 ;
30216 int ecode5 = 0 ;
30217 int val6 ;
30218 int ecode6 = 0 ;
30219 PyObject * obj0 = 0 ;
30220 PyObject * obj1 = 0 ;
30221 PyObject * obj2 = 0 ;
30222 PyObject * obj3 = 0 ;
30223 PyObject * obj4 = 0 ;
30224 PyObject * obj5 = 0 ;
30225 char * kwnames[] = {
30226 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30227 };
30228
30229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30231 if (!SWIG_IsOK(res1)) {
30232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30233 }
30234 arg1 = reinterpret_cast< wxWindow * >(argp1);
30235 ecode2 = SWIG_AsVal_int(obj1, &val2);
30236 if (!SWIG_IsOK(ecode2)) {
30237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30238 }
30239 arg2 = static_cast< int >(val2);
30240 ecode3 = SWIG_AsVal_int(obj2, &val3);
30241 if (!SWIG_IsOK(ecode3)) {
30242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30243 }
30244 arg3 = static_cast< int >(val3);
30245 ecode4 = SWIG_AsVal_int(obj3, &val4);
30246 if (!SWIG_IsOK(ecode4)) {
30247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30248 }
30249 arg4 = static_cast< int >(val4);
30250 ecode5 = SWIG_AsVal_int(obj4, &val5);
30251 if (!SWIG_IsOK(ecode5)) {
30252 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30253 }
30254 arg5 = static_cast< int >(val5);
30255 if (obj5) {
30256 ecode6 = SWIG_AsVal_int(obj5, &val6);
30257 if (!SWIG_IsOK(ecode6)) {
30258 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30259 }
30260 arg6 = static_cast< int >(val6);
30261 }
30262 {
30263 PyThreadState* __tstate = wxPyBeginAllowThreads();
30264 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30265 wxPyEndAllowThreads(__tstate);
30266 if (PyErr_Occurred()) SWIG_fail;
30267 }
30268 resultobj = SWIG_Py_Void();
30269 return resultobj;
30270 fail:
30271 return NULL;
30272 }
30273
30274
30275 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30276 PyObject *resultobj = 0;
30277 wxWindow *arg1 = (wxWindow *) 0 ;
30278 wxRect *arg2 = 0 ;
30279 int arg3 = (int) wxSIZE_AUTO ;
30280 void *argp1 = 0 ;
30281 int res1 = 0 ;
30282 wxRect temp2 ;
30283 int val3 ;
30284 int ecode3 = 0 ;
30285 PyObject * obj0 = 0 ;
30286 PyObject * obj1 = 0 ;
30287 PyObject * obj2 = 0 ;
30288 char * kwnames[] = {
30289 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30290 };
30291
30292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30294 if (!SWIG_IsOK(res1)) {
30295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30296 }
30297 arg1 = reinterpret_cast< wxWindow * >(argp1);
30298 {
30299 arg2 = &temp2;
30300 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30301 }
30302 if (obj2) {
30303 ecode3 = SWIG_AsVal_int(obj2, &val3);
30304 if (!SWIG_IsOK(ecode3)) {
30305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30306 }
30307 arg3 = static_cast< int >(val3);
30308 }
30309 {
30310 PyThreadState* __tstate = wxPyBeginAllowThreads();
30311 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30312 wxPyEndAllowThreads(__tstate);
30313 if (PyErr_Occurred()) SWIG_fail;
30314 }
30315 resultobj = SWIG_Py_Void();
30316 return resultobj;
30317 fail:
30318 return NULL;
30319 }
30320
30321
30322 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30323 PyObject *resultobj = 0;
30324 wxWindow *arg1 = (wxWindow *) 0 ;
30325 int arg2 ;
30326 int arg3 ;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 int val2 ;
30330 int ecode2 = 0 ;
30331 int val3 ;
30332 int ecode3 = 0 ;
30333 PyObject * obj0 = 0 ;
30334 PyObject * obj1 = 0 ;
30335 PyObject * obj2 = 0 ;
30336 char * kwnames[] = {
30337 (char *) "self",(char *) "width",(char *) "height", NULL
30338 };
30339
30340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30342 if (!SWIG_IsOK(res1)) {
30343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30344 }
30345 arg1 = reinterpret_cast< wxWindow * >(argp1);
30346 ecode2 = SWIG_AsVal_int(obj1, &val2);
30347 if (!SWIG_IsOK(ecode2)) {
30348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30349 }
30350 arg2 = static_cast< int >(val2);
30351 ecode3 = SWIG_AsVal_int(obj2, &val3);
30352 if (!SWIG_IsOK(ecode3)) {
30353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30354 }
30355 arg3 = static_cast< int >(val3);
30356 {
30357 PyThreadState* __tstate = wxPyBeginAllowThreads();
30358 (arg1)->SetSize(arg2,arg3);
30359 wxPyEndAllowThreads(__tstate);
30360 if (PyErr_Occurred()) SWIG_fail;
30361 }
30362 resultobj = SWIG_Py_Void();
30363 return resultobj;
30364 fail:
30365 return NULL;
30366 }
30367
30368
30369 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30370 PyObject *resultobj = 0;
30371 wxWindow *arg1 = (wxWindow *) 0 ;
30372 wxPoint *arg2 = 0 ;
30373 int arg3 = (int) wxSIZE_USE_EXISTING ;
30374 void *argp1 = 0 ;
30375 int res1 = 0 ;
30376 wxPoint temp2 ;
30377 int val3 ;
30378 int ecode3 = 0 ;
30379 PyObject * obj0 = 0 ;
30380 PyObject * obj1 = 0 ;
30381 PyObject * obj2 = 0 ;
30382 char * kwnames[] = {
30383 (char *) "self",(char *) "pt",(char *) "flags", NULL
30384 };
30385
30386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30388 if (!SWIG_IsOK(res1)) {
30389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30390 }
30391 arg1 = reinterpret_cast< wxWindow * >(argp1);
30392 {
30393 arg2 = &temp2;
30394 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30395 }
30396 if (obj2) {
30397 ecode3 = SWIG_AsVal_int(obj2, &val3);
30398 if (!SWIG_IsOK(ecode3)) {
30399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30400 }
30401 arg3 = static_cast< int >(val3);
30402 }
30403 {
30404 PyThreadState* __tstate = wxPyBeginAllowThreads();
30405 (arg1)->Move((wxPoint const &)*arg2,arg3);
30406 wxPyEndAllowThreads(__tstate);
30407 if (PyErr_Occurred()) SWIG_fail;
30408 }
30409 resultobj = SWIG_Py_Void();
30410 return resultobj;
30411 fail:
30412 return NULL;
30413 }
30414
30415
30416 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30417 PyObject *resultobj = 0;
30418 wxWindow *arg1 = (wxWindow *) 0 ;
30419 int arg2 ;
30420 int arg3 ;
30421 int arg4 = (int) wxSIZE_USE_EXISTING ;
30422 void *argp1 = 0 ;
30423 int res1 = 0 ;
30424 int val2 ;
30425 int ecode2 = 0 ;
30426 int val3 ;
30427 int ecode3 = 0 ;
30428 int val4 ;
30429 int ecode4 = 0 ;
30430 PyObject * obj0 = 0 ;
30431 PyObject * obj1 = 0 ;
30432 PyObject * obj2 = 0 ;
30433 PyObject * obj3 = 0 ;
30434 char * kwnames[] = {
30435 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30436 };
30437
30438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30440 if (!SWIG_IsOK(res1)) {
30441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30442 }
30443 arg1 = reinterpret_cast< wxWindow * >(argp1);
30444 ecode2 = SWIG_AsVal_int(obj1, &val2);
30445 if (!SWIG_IsOK(ecode2)) {
30446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30447 }
30448 arg2 = static_cast< int >(val2);
30449 ecode3 = SWIG_AsVal_int(obj2, &val3);
30450 if (!SWIG_IsOK(ecode3)) {
30451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30452 }
30453 arg3 = static_cast< int >(val3);
30454 if (obj3) {
30455 ecode4 = SWIG_AsVal_int(obj3, &val4);
30456 if (!SWIG_IsOK(ecode4)) {
30457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30458 }
30459 arg4 = static_cast< int >(val4);
30460 }
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 (arg1)->Move(arg2,arg3,arg4);
30464 wxPyEndAllowThreads(__tstate);
30465 if (PyErr_Occurred()) SWIG_fail;
30466 }
30467 resultobj = SWIG_Py_Void();
30468 return resultobj;
30469 fail:
30470 return NULL;
30471 }
30472
30473
30474 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30475 PyObject *resultobj = 0;
30476 wxWindow *arg1 = (wxWindow *) 0 ;
30477 wxSize const &arg2_defvalue = wxDefaultSize ;
30478 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30479 void *argp1 = 0 ;
30480 int res1 = 0 ;
30481 wxSize temp2 ;
30482 PyObject * obj0 = 0 ;
30483 PyObject * obj1 = 0 ;
30484 char * kwnames[] = {
30485 (char *) "self",(char *) "size", NULL
30486 };
30487
30488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30490 if (!SWIG_IsOK(res1)) {
30491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30492 }
30493 arg1 = reinterpret_cast< wxWindow * >(argp1);
30494 if (obj1) {
30495 {
30496 arg2 = &temp2;
30497 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30498 }
30499 }
30500 {
30501 PyThreadState* __tstate = wxPyBeginAllowThreads();
30502 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30503 wxPyEndAllowThreads(__tstate);
30504 if (PyErr_Occurred()) SWIG_fail;
30505 }
30506 resultobj = SWIG_Py_Void();
30507 return resultobj;
30508 fail:
30509 return NULL;
30510 }
30511
30512
30513 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30514 PyObject *resultobj = 0;
30515 wxWindow *arg1 = (wxWindow *) 0 ;
30516 void *argp1 = 0 ;
30517 int res1 = 0 ;
30518 PyObject *swig_obj[1] ;
30519
30520 if (!args) SWIG_fail;
30521 swig_obj[0] = args;
30522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30523 if (!SWIG_IsOK(res1)) {
30524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30525 }
30526 arg1 = reinterpret_cast< wxWindow * >(argp1);
30527 {
30528 PyThreadState* __tstate = wxPyBeginAllowThreads();
30529 (arg1)->Raise();
30530 wxPyEndAllowThreads(__tstate);
30531 if (PyErr_Occurred()) SWIG_fail;
30532 }
30533 resultobj = SWIG_Py_Void();
30534 return resultobj;
30535 fail:
30536 return NULL;
30537 }
30538
30539
30540 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30541 PyObject *resultobj = 0;
30542 wxWindow *arg1 = (wxWindow *) 0 ;
30543 void *argp1 = 0 ;
30544 int res1 = 0 ;
30545 PyObject *swig_obj[1] ;
30546
30547 if (!args) SWIG_fail;
30548 swig_obj[0] = args;
30549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30550 if (!SWIG_IsOK(res1)) {
30551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30552 }
30553 arg1 = reinterpret_cast< wxWindow * >(argp1);
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 (arg1)->Lower();
30557 wxPyEndAllowThreads(__tstate);
30558 if (PyErr_Occurred()) SWIG_fail;
30559 }
30560 resultobj = SWIG_Py_Void();
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30568 PyObject *resultobj = 0;
30569 wxWindow *arg1 = (wxWindow *) 0 ;
30570 wxSize *arg2 = 0 ;
30571 void *argp1 = 0 ;
30572 int res1 = 0 ;
30573 wxSize temp2 ;
30574 PyObject * obj0 = 0 ;
30575 PyObject * obj1 = 0 ;
30576 char * kwnames[] = {
30577 (char *) "self",(char *) "size", NULL
30578 };
30579
30580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30582 if (!SWIG_IsOK(res1)) {
30583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30584 }
30585 arg1 = reinterpret_cast< wxWindow * >(argp1);
30586 {
30587 arg2 = &temp2;
30588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30589 }
30590 {
30591 PyThreadState* __tstate = wxPyBeginAllowThreads();
30592 (arg1)->SetClientSize((wxSize const &)*arg2);
30593 wxPyEndAllowThreads(__tstate);
30594 if (PyErr_Occurred()) SWIG_fail;
30595 }
30596 resultobj = SWIG_Py_Void();
30597 return resultobj;
30598 fail:
30599 return NULL;
30600 }
30601
30602
30603 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30604 PyObject *resultobj = 0;
30605 wxWindow *arg1 = (wxWindow *) 0 ;
30606 int arg2 ;
30607 int arg3 ;
30608 void *argp1 = 0 ;
30609 int res1 = 0 ;
30610 int val2 ;
30611 int ecode2 = 0 ;
30612 int val3 ;
30613 int ecode3 = 0 ;
30614 PyObject * obj0 = 0 ;
30615 PyObject * obj1 = 0 ;
30616 PyObject * obj2 = 0 ;
30617 char * kwnames[] = {
30618 (char *) "self",(char *) "width",(char *) "height", NULL
30619 };
30620
30621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30623 if (!SWIG_IsOK(res1)) {
30624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30625 }
30626 arg1 = reinterpret_cast< wxWindow * >(argp1);
30627 ecode2 = SWIG_AsVal_int(obj1, &val2);
30628 if (!SWIG_IsOK(ecode2)) {
30629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30630 }
30631 arg2 = static_cast< int >(val2);
30632 ecode3 = SWIG_AsVal_int(obj2, &val3);
30633 if (!SWIG_IsOK(ecode3)) {
30634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30635 }
30636 arg3 = static_cast< int >(val3);
30637 {
30638 PyThreadState* __tstate = wxPyBeginAllowThreads();
30639 (arg1)->SetClientSize(arg2,arg3);
30640 wxPyEndAllowThreads(__tstate);
30641 if (PyErr_Occurred()) SWIG_fail;
30642 }
30643 resultobj = SWIG_Py_Void();
30644 return resultobj;
30645 fail:
30646 return NULL;
30647 }
30648
30649
30650 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30651 PyObject *resultobj = 0;
30652 wxWindow *arg1 = (wxWindow *) 0 ;
30653 wxRect *arg2 = 0 ;
30654 void *argp1 = 0 ;
30655 int res1 = 0 ;
30656 wxRect temp2 ;
30657 PyObject * obj0 = 0 ;
30658 PyObject * obj1 = 0 ;
30659 char * kwnames[] = {
30660 (char *) "self",(char *) "rect", NULL
30661 };
30662
30663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30665 if (!SWIG_IsOK(res1)) {
30666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30667 }
30668 arg1 = reinterpret_cast< wxWindow * >(argp1);
30669 {
30670 arg2 = &temp2;
30671 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30672 }
30673 {
30674 PyThreadState* __tstate = wxPyBeginAllowThreads();
30675 (arg1)->SetClientSize((wxRect const &)*arg2);
30676 wxPyEndAllowThreads(__tstate);
30677 if (PyErr_Occurred()) SWIG_fail;
30678 }
30679 resultobj = SWIG_Py_Void();
30680 return resultobj;
30681 fail:
30682 return NULL;
30683 }
30684
30685
30686 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30687 PyObject *resultobj = 0;
30688 wxWindow *arg1 = (wxWindow *) 0 ;
30689 wxPoint result;
30690 void *argp1 = 0 ;
30691 int res1 = 0 ;
30692 PyObject *swig_obj[1] ;
30693
30694 if (!args) SWIG_fail;
30695 swig_obj[0] = args;
30696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30697 if (!SWIG_IsOK(res1)) {
30698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30699 }
30700 arg1 = reinterpret_cast< wxWindow * >(argp1);
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 result = ((wxWindow const *)arg1)->GetPosition();
30704 wxPyEndAllowThreads(__tstate);
30705 if (PyErr_Occurred()) SWIG_fail;
30706 }
30707 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30708 return resultobj;
30709 fail:
30710 return NULL;
30711 }
30712
30713
30714 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30715 PyObject *resultobj = 0;
30716 wxWindow *arg1 = (wxWindow *) 0 ;
30717 int *arg2 = (int *) 0 ;
30718 int *arg3 = (int *) 0 ;
30719 void *argp1 = 0 ;
30720 int res1 = 0 ;
30721 int temp2 ;
30722 int res2 = SWIG_TMPOBJ ;
30723 int temp3 ;
30724 int res3 = SWIG_TMPOBJ ;
30725 PyObject *swig_obj[1] ;
30726
30727 arg2 = &temp2;
30728 arg3 = &temp3;
30729 if (!args) SWIG_fail;
30730 swig_obj[0] = args;
30731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30732 if (!SWIG_IsOK(res1)) {
30733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30734 }
30735 arg1 = reinterpret_cast< wxWindow * >(argp1);
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 resultobj = SWIG_Py_Void();
30743 if (SWIG_IsTmpObj(res2)) {
30744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30745 } else {
30746 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30748 }
30749 if (SWIG_IsTmpObj(res3)) {
30750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30751 } else {
30752 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30754 }
30755 return resultobj;
30756 fail:
30757 return NULL;
30758 }
30759
30760
30761 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30762 PyObject *resultobj = 0;
30763 wxWindow *arg1 = (wxWindow *) 0 ;
30764 wxPoint result;
30765 void *argp1 = 0 ;
30766 int res1 = 0 ;
30767 PyObject *swig_obj[1] ;
30768
30769 if (!args) SWIG_fail;
30770 swig_obj[0] = args;
30771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30772 if (!SWIG_IsOK(res1)) {
30773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30774 }
30775 arg1 = reinterpret_cast< wxWindow * >(argp1);
30776 {
30777 PyThreadState* __tstate = wxPyBeginAllowThreads();
30778 result = ((wxWindow const *)arg1)->GetScreenPosition();
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30790 PyObject *resultobj = 0;
30791 wxWindow *arg1 = (wxWindow *) 0 ;
30792 int *arg2 = (int *) 0 ;
30793 int *arg3 = (int *) 0 ;
30794 void *argp1 = 0 ;
30795 int res1 = 0 ;
30796 int temp2 ;
30797 int res2 = SWIG_TMPOBJ ;
30798 int temp3 ;
30799 int res3 = SWIG_TMPOBJ ;
30800 PyObject *swig_obj[1] ;
30801
30802 arg2 = &temp2;
30803 arg3 = &temp3;
30804 if (!args) SWIG_fail;
30805 swig_obj[0] = args;
30806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30807 if (!SWIG_IsOK(res1)) {
30808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30809 }
30810 arg1 = reinterpret_cast< wxWindow * >(argp1);
30811 {
30812 PyThreadState* __tstate = wxPyBeginAllowThreads();
30813 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30814 wxPyEndAllowThreads(__tstate);
30815 if (PyErr_Occurred()) SWIG_fail;
30816 }
30817 resultobj = SWIG_Py_Void();
30818 if (SWIG_IsTmpObj(res2)) {
30819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30820 } else {
30821 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30823 }
30824 if (SWIG_IsTmpObj(res3)) {
30825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30826 } else {
30827 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30829 }
30830 return resultobj;
30831 fail:
30832 return NULL;
30833 }
30834
30835
30836 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30837 PyObject *resultobj = 0;
30838 wxWindow *arg1 = (wxWindow *) 0 ;
30839 wxRect result;
30840 void *argp1 = 0 ;
30841 int res1 = 0 ;
30842 PyObject *swig_obj[1] ;
30843
30844 if (!args) SWIG_fail;
30845 swig_obj[0] = args;
30846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30847 if (!SWIG_IsOK(res1)) {
30848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30849 }
30850 arg1 = reinterpret_cast< wxWindow * >(argp1);
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = ((wxWindow const *)arg1)->GetScreenRect();
30854 wxPyEndAllowThreads(__tstate);
30855 if (PyErr_Occurred()) SWIG_fail;
30856 }
30857 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30865 PyObject *resultobj = 0;
30866 wxWindow *arg1 = (wxWindow *) 0 ;
30867 wxSize result;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 PyObject *swig_obj[1] ;
30871
30872 if (!args) SWIG_fail;
30873 swig_obj[0] = args;
30874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30875 if (!SWIG_IsOK(res1)) {
30876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30877 }
30878 arg1 = reinterpret_cast< wxWindow * >(argp1);
30879 {
30880 PyThreadState* __tstate = wxPyBeginAllowThreads();
30881 result = ((wxWindow const *)arg1)->GetSize();
30882 wxPyEndAllowThreads(__tstate);
30883 if (PyErr_Occurred()) SWIG_fail;
30884 }
30885 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30886 return resultobj;
30887 fail:
30888 return NULL;
30889 }
30890
30891
30892 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30893 PyObject *resultobj = 0;
30894 wxWindow *arg1 = (wxWindow *) 0 ;
30895 int *arg2 = (int *) 0 ;
30896 int *arg3 = (int *) 0 ;
30897 void *argp1 = 0 ;
30898 int res1 = 0 ;
30899 int temp2 ;
30900 int res2 = SWIG_TMPOBJ ;
30901 int temp3 ;
30902 int res3 = SWIG_TMPOBJ ;
30903 PyObject *swig_obj[1] ;
30904
30905 arg2 = &temp2;
30906 arg3 = &temp3;
30907 if (!args) SWIG_fail;
30908 swig_obj[0] = args;
30909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30910 if (!SWIG_IsOK(res1)) {
30911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30912 }
30913 arg1 = reinterpret_cast< wxWindow * >(argp1);
30914 {
30915 PyThreadState* __tstate = wxPyBeginAllowThreads();
30916 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 resultobj = SWIG_Py_Void();
30921 if (SWIG_IsTmpObj(res2)) {
30922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30923 } else {
30924 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30925 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30926 }
30927 if (SWIG_IsTmpObj(res3)) {
30928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30929 } else {
30930 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30932 }
30933 return resultobj;
30934 fail:
30935 return NULL;
30936 }
30937
30938
30939 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30940 PyObject *resultobj = 0;
30941 wxWindow *arg1 = (wxWindow *) 0 ;
30942 wxRect result;
30943 void *argp1 = 0 ;
30944 int res1 = 0 ;
30945 PyObject *swig_obj[1] ;
30946
30947 if (!args) SWIG_fail;
30948 swig_obj[0] = args;
30949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30950 if (!SWIG_IsOK(res1)) {
30951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30952 }
30953 arg1 = reinterpret_cast< wxWindow * >(argp1);
30954 {
30955 PyThreadState* __tstate = wxPyBeginAllowThreads();
30956 result = ((wxWindow const *)arg1)->GetRect();
30957 wxPyEndAllowThreads(__tstate);
30958 if (PyErr_Occurred()) SWIG_fail;
30959 }
30960 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30961 return resultobj;
30962 fail:
30963 return NULL;
30964 }
30965
30966
30967 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30968 PyObject *resultobj = 0;
30969 wxWindow *arg1 = (wxWindow *) 0 ;
30970 wxSize result;
30971 void *argp1 = 0 ;
30972 int res1 = 0 ;
30973 PyObject *swig_obj[1] ;
30974
30975 if (!args) SWIG_fail;
30976 swig_obj[0] = args;
30977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30978 if (!SWIG_IsOK(res1)) {
30979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30980 }
30981 arg1 = reinterpret_cast< wxWindow * >(argp1);
30982 {
30983 PyThreadState* __tstate = wxPyBeginAllowThreads();
30984 result = ((wxWindow const *)arg1)->GetClientSize();
30985 wxPyEndAllowThreads(__tstate);
30986 if (PyErr_Occurred()) SWIG_fail;
30987 }
30988 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30989 return resultobj;
30990 fail:
30991 return NULL;
30992 }
30993
30994
30995 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30996 PyObject *resultobj = 0;
30997 wxWindow *arg1 = (wxWindow *) 0 ;
30998 int *arg2 = (int *) 0 ;
30999 int *arg3 = (int *) 0 ;
31000 void *argp1 = 0 ;
31001 int res1 = 0 ;
31002 int temp2 ;
31003 int res2 = SWIG_TMPOBJ ;
31004 int temp3 ;
31005 int res3 = SWIG_TMPOBJ ;
31006 PyObject *swig_obj[1] ;
31007
31008 arg2 = &temp2;
31009 arg3 = &temp3;
31010 if (!args) SWIG_fail;
31011 swig_obj[0] = args;
31012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31013 if (!SWIG_IsOK(res1)) {
31014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31015 }
31016 arg1 = reinterpret_cast< wxWindow * >(argp1);
31017 {
31018 PyThreadState* __tstate = wxPyBeginAllowThreads();
31019 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31020 wxPyEndAllowThreads(__tstate);
31021 if (PyErr_Occurred()) SWIG_fail;
31022 }
31023 resultobj = SWIG_Py_Void();
31024 if (SWIG_IsTmpObj(res2)) {
31025 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31026 } else {
31027 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31028 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31029 }
31030 if (SWIG_IsTmpObj(res3)) {
31031 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31032 } else {
31033 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31034 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31035 }
31036 return resultobj;
31037 fail:
31038 return NULL;
31039 }
31040
31041
31042 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31043 PyObject *resultobj = 0;
31044 wxWindow *arg1 = (wxWindow *) 0 ;
31045 wxPoint result;
31046 void *argp1 = 0 ;
31047 int res1 = 0 ;
31048 PyObject *swig_obj[1] ;
31049
31050 if (!args) SWIG_fail;
31051 swig_obj[0] = args;
31052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31053 if (!SWIG_IsOK(res1)) {
31054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31055 }
31056 arg1 = reinterpret_cast< wxWindow * >(argp1);
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31060 wxPyEndAllowThreads(__tstate);
31061 if (PyErr_Occurred()) SWIG_fail;
31062 }
31063 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31064 return resultobj;
31065 fail:
31066 return NULL;
31067 }
31068
31069
31070 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31071 PyObject *resultobj = 0;
31072 wxWindow *arg1 = (wxWindow *) 0 ;
31073 wxRect result;
31074 void *argp1 = 0 ;
31075 int res1 = 0 ;
31076 PyObject *swig_obj[1] ;
31077
31078 if (!args) SWIG_fail;
31079 swig_obj[0] = args;
31080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31081 if (!SWIG_IsOK(res1)) {
31082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31083 }
31084 arg1 = reinterpret_cast< wxWindow * >(argp1);
31085 {
31086 PyThreadState* __tstate = wxPyBeginAllowThreads();
31087 result = ((wxWindow const *)arg1)->GetClientRect();
31088 wxPyEndAllowThreads(__tstate);
31089 if (PyErr_Occurred()) SWIG_fail;
31090 }
31091 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31092 return resultobj;
31093 fail:
31094 return NULL;
31095 }
31096
31097
31098 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31099 PyObject *resultobj = 0;
31100 wxWindow *arg1 = (wxWindow *) 0 ;
31101 wxSize result;
31102 void *argp1 = 0 ;
31103 int res1 = 0 ;
31104 PyObject *swig_obj[1] ;
31105
31106 if (!args) SWIG_fail;
31107 swig_obj[0] = args;
31108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31109 if (!SWIG_IsOK(res1)) {
31110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31111 }
31112 arg1 = reinterpret_cast< wxWindow * >(argp1);
31113 {
31114 PyThreadState* __tstate = wxPyBeginAllowThreads();
31115 result = ((wxWindow const *)arg1)->GetBestSize();
31116 wxPyEndAllowThreads(__tstate);
31117 if (PyErr_Occurred()) SWIG_fail;
31118 }
31119 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31127 PyObject *resultobj = 0;
31128 wxWindow *arg1 = (wxWindow *) 0 ;
31129 int *arg2 = (int *) 0 ;
31130 int *arg3 = (int *) 0 ;
31131 void *argp1 = 0 ;
31132 int res1 = 0 ;
31133 int temp2 ;
31134 int res2 = SWIG_TMPOBJ ;
31135 int temp3 ;
31136 int res3 = SWIG_TMPOBJ ;
31137 PyObject *swig_obj[1] ;
31138
31139 arg2 = &temp2;
31140 arg3 = &temp3;
31141 if (!args) SWIG_fail;
31142 swig_obj[0] = args;
31143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31144 if (!SWIG_IsOK(res1)) {
31145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31146 }
31147 arg1 = reinterpret_cast< wxWindow * >(argp1);
31148 {
31149 PyThreadState* __tstate = wxPyBeginAllowThreads();
31150 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31151 wxPyEndAllowThreads(__tstate);
31152 if (PyErr_Occurred()) SWIG_fail;
31153 }
31154 resultobj = SWIG_Py_Void();
31155 if (SWIG_IsTmpObj(res2)) {
31156 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31157 } else {
31158 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31159 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31160 }
31161 if (SWIG_IsTmpObj(res3)) {
31162 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31163 } else {
31164 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31165 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31166 }
31167 return resultobj;
31168 fail:
31169 return NULL;
31170 }
31171
31172
31173 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31174 PyObject *resultobj = 0;
31175 wxWindow *arg1 = (wxWindow *) 0 ;
31176 void *argp1 = 0 ;
31177 int res1 = 0 ;
31178 PyObject *swig_obj[1] ;
31179
31180 if (!args) SWIG_fail;
31181 swig_obj[0] = args;
31182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31183 if (!SWIG_IsOK(res1)) {
31184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31185 }
31186 arg1 = reinterpret_cast< wxWindow * >(argp1);
31187 {
31188 PyThreadState* __tstate = wxPyBeginAllowThreads();
31189 (arg1)->InvalidateBestSize();
31190 wxPyEndAllowThreads(__tstate);
31191 if (PyErr_Occurred()) SWIG_fail;
31192 }
31193 resultobj = SWIG_Py_Void();
31194 return resultobj;
31195 fail:
31196 return NULL;
31197 }
31198
31199
31200 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31201 PyObject *resultobj = 0;
31202 wxWindow *arg1 = (wxWindow *) 0 ;
31203 wxSize *arg2 = 0 ;
31204 void *argp1 = 0 ;
31205 int res1 = 0 ;
31206 wxSize temp2 ;
31207 PyObject * obj0 = 0 ;
31208 PyObject * obj1 = 0 ;
31209 char * kwnames[] = {
31210 (char *) "self",(char *) "size", NULL
31211 };
31212
31213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31215 if (!SWIG_IsOK(res1)) {
31216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31217 }
31218 arg1 = reinterpret_cast< wxWindow * >(argp1);
31219 {
31220 arg2 = &temp2;
31221 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31222 }
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31226 wxPyEndAllowThreads(__tstate);
31227 if (PyErr_Occurred()) SWIG_fail;
31228 }
31229 resultobj = SWIG_Py_Void();
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31237 PyObject *resultobj = 0;
31238 wxWindow *arg1 = (wxWindow *) 0 ;
31239 wxSize result;
31240 void *argp1 = 0 ;
31241 int res1 = 0 ;
31242 PyObject *swig_obj[1] ;
31243
31244 if (!args) SWIG_fail;
31245 swig_obj[0] = args;
31246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31247 if (!SWIG_IsOK(res1)) {
31248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31249 }
31250 arg1 = reinterpret_cast< wxWindow * >(argp1);
31251 {
31252 PyThreadState* __tstate = wxPyBeginAllowThreads();
31253 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31254 wxPyEndAllowThreads(__tstate);
31255 if (PyErr_Occurred()) SWIG_fail;
31256 }
31257 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31258 return resultobj;
31259 fail:
31260 return NULL;
31261 }
31262
31263
31264 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31265 PyObject *resultobj = 0;
31266 wxWindow *arg1 = (wxWindow *) 0 ;
31267 wxSize result;
31268 void *argp1 = 0 ;
31269 int res1 = 0 ;
31270 PyObject *swig_obj[1] ;
31271
31272 if (!args) SWIG_fail;
31273 swig_obj[0] = args;
31274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31275 if (!SWIG_IsOK(res1)) {
31276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31277 }
31278 arg1 = reinterpret_cast< wxWindow * >(argp1);
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31293 PyObject *resultobj = 0;
31294 wxWindow *arg1 = (wxWindow *) 0 ;
31295 int arg2 = (int) wxBOTH ;
31296 void *argp1 = 0 ;
31297 int res1 = 0 ;
31298 int val2 ;
31299 int ecode2 = 0 ;
31300 PyObject * obj0 = 0 ;
31301 PyObject * obj1 = 0 ;
31302 char * kwnames[] = {
31303 (char *) "self",(char *) "direction", NULL
31304 };
31305
31306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31308 if (!SWIG_IsOK(res1)) {
31309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31310 }
31311 arg1 = reinterpret_cast< wxWindow * >(argp1);
31312 if (obj1) {
31313 ecode2 = SWIG_AsVal_int(obj1, &val2);
31314 if (!SWIG_IsOK(ecode2)) {
31315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31316 }
31317 arg2 = static_cast< int >(val2);
31318 }
31319 {
31320 PyThreadState* __tstate = wxPyBeginAllowThreads();
31321 (arg1)->Center(arg2);
31322 wxPyEndAllowThreads(__tstate);
31323 if (PyErr_Occurred()) SWIG_fail;
31324 }
31325 resultobj = SWIG_Py_Void();
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj = 0;
31334 wxWindow *arg1 = (wxWindow *) 0 ;
31335 int arg2 = (int) wxBOTH ;
31336 void *argp1 = 0 ;
31337 int res1 = 0 ;
31338 int val2 ;
31339 int ecode2 = 0 ;
31340 PyObject * obj0 = 0 ;
31341 PyObject * obj1 = 0 ;
31342 char * kwnames[] = {
31343 (char *) "self",(char *) "dir", NULL
31344 };
31345
31346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31348 if (!SWIG_IsOK(res1)) {
31349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31350 }
31351 arg1 = reinterpret_cast< wxWindow * >(argp1);
31352 if (obj1) {
31353 ecode2 = SWIG_AsVal_int(obj1, &val2);
31354 if (!SWIG_IsOK(ecode2)) {
31355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31356 }
31357 arg2 = static_cast< int >(val2);
31358 }
31359 {
31360 PyThreadState* __tstate = wxPyBeginAllowThreads();
31361 (arg1)->CenterOnParent(arg2);
31362 wxPyEndAllowThreads(__tstate);
31363 if (PyErr_Occurred()) SWIG_fail;
31364 }
31365 resultobj = SWIG_Py_Void();
31366 return resultobj;
31367 fail:
31368 return NULL;
31369 }
31370
31371
31372 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31373 PyObject *resultobj = 0;
31374 wxWindow *arg1 = (wxWindow *) 0 ;
31375 void *argp1 = 0 ;
31376 int res1 = 0 ;
31377 PyObject *swig_obj[1] ;
31378
31379 if (!args) SWIG_fail;
31380 swig_obj[0] = args;
31381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31382 if (!SWIG_IsOK(res1)) {
31383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31384 }
31385 arg1 = reinterpret_cast< wxWindow * >(argp1);
31386 {
31387 PyThreadState* __tstate = wxPyBeginAllowThreads();
31388 (arg1)->Fit();
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 resultobj = SWIG_Py_Void();
31393 return resultobj;
31394 fail:
31395 return NULL;
31396 }
31397
31398
31399 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31400 PyObject *resultobj = 0;
31401 wxWindow *arg1 = (wxWindow *) 0 ;
31402 void *argp1 = 0 ;
31403 int res1 = 0 ;
31404 PyObject *swig_obj[1] ;
31405
31406 if (!args) SWIG_fail;
31407 swig_obj[0] = args;
31408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31409 if (!SWIG_IsOK(res1)) {
31410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31411 }
31412 arg1 = reinterpret_cast< wxWindow * >(argp1);
31413 {
31414 PyThreadState* __tstate = wxPyBeginAllowThreads();
31415 (arg1)->FitInside();
31416 wxPyEndAllowThreads(__tstate);
31417 if (PyErr_Occurred()) SWIG_fail;
31418 }
31419 resultobj = SWIG_Py_Void();
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31427 PyObject *resultobj = 0;
31428 wxWindow *arg1 = (wxWindow *) 0 ;
31429 int arg2 ;
31430 int arg3 ;
31431 int arg4 = (int) -1 ;
31432 int arg5 = (int) -1 ;
31433 int arg6 = (int) -1 ;
31434 int arg7 = (int) -1 ;
31435 void *argp1 = 0 ;
31436 int res1 = 0 ;
31437 int val2 ;
31438 int ecode2 = 0 ;
31439 int val3 ;
31440 int ecode3 = 0 ;
31441 int val4 ;
31442 int ecode4 = 0 ;
31443 int val5 ;
31444 int ecode5 = 0 ;
31445 int val6 ;
31446 int ecode6 = 0 ;
31447 int val7 ;
31448 int ecode7 = 0 ;
31449 PyObject * obj0 = 0 ;
31450 PyObject * obj1 = 0 ;
31451 PyObject * obj2 = 0 ;
31452 PyObject * obj3 = 0 ;
31453 PyObject * obj4 = 0 ;
31454 PyObject * obj5 = 0 ;
31455 PyObject * obj6 = 0 ;
31456 char * kwnames[] = {
31457 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31458 };
31459
31460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31462 if (!SWIG_IsOK(res1)) {
31463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31464 }
31465 arg1 = reinterpret_cast< wxWindow * >(argp1);
31466 ecode2 = SWIG_AsVal_int(obj1, &val2);
31467 if (!SWIG_IsOK(ecode2)) {
31468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31469 }
31470 arg2 = static_cast< int >(val2);
31471 ecode3 = SWIG_AsVal_int(obj2, &val3);
31472 if (!SWIG_IsOK(ecode3)) {
31473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31474 }
31475 arg3 = static_cast< int >(val3);
31476 if (obj3) {
31477 ecode4 = SWIG_AsVal_int(obj3, &val4);
31478 if (!SWIG_IsOK(ecode4)) {
31479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31480 }
31481 arg4 = static_cast< int >(val4);
31482 }
31483 if (obj4) {
31484 ecode5 = SWIG_AsVal_int(obj4, &val5);
31485 if (!SWIG_IsOK(ecode5)) {
31486 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31487 }
31488 arg5 = static_cast< int >(val5);
31489 }
31490 if (obj5) {
31491 ecode6 = SWIG_AsVal_int(obj5, &val6);
31492 if (!SWIG_IsOK(ecode6)) {
31493 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31494 }
31495 arg6 = static_cast< int >(val6);
31496 }
31497 if (obj6) {
31498 ecode7 = SWIG_AsVal_int(obj6, &val7);
31499 if (!SWIG_IsOK(ecode7)) {
31500 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31501 }
31502 arg7 = static_cast< int >(val7);
31503 }
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 resultobj = SWIG_Py_Void();
31511 return resultobj;
31512 fail:
31513 return NULL;
31514 }
31515
31516
31517 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31518 PyObject *resultobj = 0;
31519 wxWindow *arg1 = (wxWindow *) 0 ;
31520 wxSize *arg2 = 0 ;
31521 wxSize const &arg3_defvalue = wxDefaultSize ;
31522 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31523 wxSize const &arg4_defvalue = wxDefaultSize ;
31524 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31525 void *argp1 = 0 ;
31526 int res1 = 0 ;
31527 wxSize temp2 ;
31528 wxSize temp3 ;
31529 wxSize temp4 ;
31530 PyObject * obj0 = 0 ;
31531 PyObject * obj1 = 0 ;
31532 PyObject * obj2 = 0 ;
31533 PyObject * obj3 = 0 ;
31534 char * kwnames[] = {
31535 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31536 };
31537
31538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31540 if (!SWIG_IsOK(res1)) {
31541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31542 }
31543 arg1 = reinterpret_cast< wxWindow * >(argp1);
31544 {
31545 arg2 = &temp2;
31546 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31547 }
31548 if (obj2) {
31549 {
31550 arg3 = &temp3;
31551 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31552 }
31553 }
31554 if (obj3) {
31555 {
31556 arg4 = &temp4;
31557 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31558 }
31559 }
31560 {
31561 PyThreadState* __tstate = wxPyBeginAllowThreads();
31562 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31563 wxPyEndAllowThreads(__tstate);
31564 if (PyErr_Occurred()) SWIG_fail;
31565 }
31566 resultobj = SWIG_Py_Void();
31567 return resultobj;
31568 fail:
31569 return NULL;
31570 }
31571
31572
31573 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31574 PyObject *resultobj = 0;
31575 wxWindow *arg1 = (wxWindow *) 0 ;
31576 int arg2 ;
31577 int arg3 ;
31578 int arg4 = (int) -1 ;
31579 int arg5 = (int) -1 ;
31580 void *argp1 = 0 ;
31581 int res1 = 0 ;
31582 int val2 ;
31583 int ecode2 = 0 ;
31584 int val3 ;
31585 int ecode3 = 0 ;
31586 int val4 ;
31587 int ecode4 = 0 ;
31588 int val5 ;
31589 int ecode5 = 0 ;
31590 PyObject * obj0 = 0 ;
31591 PyObject * obj1 = 0 ;
31592 PyObject * obj2 = 0 ;
31593 PyObject * obj3 = 0 ;
31594 PyObject * obj4 = 0 ;
31595 char * kwnames[] = {
31596 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31597 };
31598
31599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31601 if (!SWIG_IsOK(res1)) {
31602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31603 }
31604 arg1 = reinterpret_cast< wxWindow * >(argp1);
31605 ecode2 = SWIG_AsVal_int(obj1, &val2);
31606 if (!SWIG_IsOK(ecode2)) {
31607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31608 }
31609 arg2 = static_cast< int >(val2);
31610 ecode3 = SWIG_AsVal_int(obj2, &val3);
31611 if (!SWIG_IsOK(ecode3)) {
31612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31613 }
31614 arg3 = static_cast< int >(val3);
31615 if (obj3) {
31616 ecode4 = SWIG_AsVal_int(obj3, &val4);
31617 if (!SWIG_IsOK(ecode4)) {
31618 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31619 }
31620 arg4 = static_cast< int >(val4);
31621 }
31622 if (obj4) {
31623 ecode5 = SWIG_AsVal_int(obj4, &val5);
31624 if (!SWIG_IsOK(ecode5)) {
31625 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31626 }
31627 arg5 = static_cast< int >(val5);
31628 }
31629 {
31630 PyThreadState* __tstate = wxPyBeginAllowThreads();
31631 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31632 wxPyEndAllowThreads(__tstate);
31633 if (PyErr_Occurred()) SWIG_fail;
31634 }
31635 resultobj = SWIG_Py_Void();
31636 return resultobj;
31637 fail:
31638 return NULL;
31639 }
31640
31641
31642 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31643 PyObject *resultobj = 0;
31644 wxWindow *arg1 = (wxWindow *) 0 ;
31645 wxSize *arg2 = 0 ;
31646 wxSize const &arg3_defvalue = wxDefaultSize ;
31647 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31648 void *argp1 = 0 ;
31649 int res1 = 0 ;
31650 wxSize temp2 ;
31651 wxSize temp3 ;
31652 PyObject * obj0 = 0 ;
31653 PyObject * obj1 = 0 ;
31654 PyObject * obj2 = 0 ;
31655 char * kwnames[] = {
31656 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31657 };
31658
31659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31661 if (!SWIG_IsOK(res1)) {
31662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31663 }
31664 arg1 = reinterpret_cast< wxWindow * >(argp1);
31665 {
31666 arg2 = &temp2;
31667 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31668 }
31669 if (obj2) {
31670 {
31671 arg3 = &temp3;
31672 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31673 }
31674 }
31675 {
31676 PyThreadState* __tstate = wxPyBeginAllowThreads();
31677 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 resultobj = SWIG_Py_Void();
31682 return resultobj;
31683 fail:
31684 return NULL;
31685 }
31686
31687
31688 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31689 PyObject *resultobj = 0;
31690 wxWindow *arg1 = (wxWindow *) 0 ;
31691 wxSize result;
31692 void *argp1 = 0 ;
31693 int res1 = 0 ;
31694 PyObject *swig_obj[1] ;
31695
31696 if (!args) SWIG_fail;
31697 swig_obj[0] = args;
31698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31699 if (!SWIG_IsOK(res1)) {
31700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31701 }
31702 arg1 = reinterpret_cast< wxWindow * >(argp1);
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 result = ((wxWindow const *)arg1)->GetMaxSize();
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31717 PyObject *resultobj = 0;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 wxSize result;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 PyObject *swig_obj[1] ;
31723
31724 if (!args) SWIG_fail;
31725 swig_obj[0] = args;
31726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31727 if (!SWIG_IsOK(res1)) {
31728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31729 }
31730 arg1 = reinterpret_cast< wxWindow * >(argp1);
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 result = ((wxWindow const *)arg1)->GetMinSize();
31734 wxPyEndAllowThreads(__tstate);
31735 if (PyErr_Occurred()) SWIG_fail;
31736 }
31737 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31738 return resultobj;
31739 fail:
31740 return NULL;
31741 }
31742
31743
31744 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31745 PyObject *resultobj = 0;
31746 wxWindow *arg1 = (wxWindow *) 0 ;
31747 wxSize *arg2 = 0 ;
31748 void *argp1 = 0 ;
31749 int res1 = 0 ;
31750 wxSize temp2 ;
31751 PyObject * obj0 = 0 ;
31752 PyObject * obj1 = 0 ;
31753 char * kwnames[] = {
31754 (char *) "self",(char *) "minSize", NULL
31755 };
31756
31757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31759 if (!SWIG_IsOK(res1)) {
31760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31761 }
31762 arg1 = reinterpret_cast< wxWindow * >(argp1);
31763 {
31764 arg2 = &temp2;
31765 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31766 }
31767 {
31768 PyThreadState* __tstate = wxPyBeginAllowThreads();
31769 (arg1)->SetMinSize((wxSize const &)*arg2);
31770 wxPyEndAllowThreads(__tstate);
31771 if (PyErr_Occurred()) SWIG_fail;
31772 }
31773 resultobj = SWIG_Py_Void();
31774 return resultobj;
31775 fail:
31776 return NULL;
31777 }
31778
31779
31780 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31781 PyObject *resultobj = 0;
31782 wxWindow *arg1 = (wxWindow *) 0 ;
31783 wxSize *arg2 = 0 ;
31784 void *argp1 = 0 ;
31785 int res1 = 0 ;
31786 wxSize temp2 ;
31787 PyObject * obj0 = 0 ;
31788 PyObject * obj1 = 0 ;
31789 char * kwnames[] = {
31790 (char *) "self",(char *) "maxSize", NULL
31791 };
31792
31793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31795 if (!SWIG_IsOK(res1)) {
31796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31797 }
31798 arg1 = reinterpret_cast< wxWindow * >(argp1);
31799 {
31800 arg2 = &temp2;
31801 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31802 }
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 (arg1)->SetMaxSize((wxSize const &)*arg2);
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 resultobj = SWIG_Py_Void();
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31817 PyObject *resultobj = 0;
31818 wxWindow *arg1 = (wxWindow *) 0 ;
31819 int result;
31820 void *argp1 = 0 ;
31821 int res1 = 0 ;
31822 PyObject *swig_obj[1] ;
31823
31824 if (!args) SWIG_fail;
31825 swig_obj[0] = args;
31826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31827 if (!SWIG_IsOK(res1)) {
31828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31829 }
31830 arg1 = reinterpret_cast< wxWindow * >(argp1);
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31834 wxPyEndAllowThreads(__tstate);
31835 if (PyErr_Occurred()) SWIG_fail;
31836 }
31837 resultobj = SWIG_From_int(static_cast< int >(result));
31838 return resultobj;
31839 fail:
31840 return NULL;
31841 }
31842
31843
31844 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31845 PyObject *resultobj = 0;
31846 wxWindow *arg1 = (wxWindow *) 0 ;
31847 int result;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 PyObject *swig_obj[1] ;
31851
31852 if (!args) SWIG_fail;
31853 swig_obj[0] = args;
31854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31855 if (!SWIG_IsOK(res1)) {
31856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31857 }
31858 arg1 = reinterpret_cast< wxWindow * >(argp1);
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31862 wxPyEndAllowThreads(__tstate);
31863 if (PyErr_Occurred()) SWIG_fail;
31864 }
31865 resultobj = SWIG_From_int(static_cast< int >(result));
31866 return resultobj;
31867 fail:
31868 return NULL;
31869 }
31870
31871
31872 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31873 PyObject *resultobj = 0;
31874 wxWindow *arg1 = (wxWindow *) 0 ;
31875 int result;
31876 void *argp1 = 0 ;
31877 int res1 = 0 ;
31878 PyObject *swig_obj[1] ;
31879
31880 if (!args) SWIG_fail;
31881 swig_obj[0] = args;
31882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31883 if (!SWIG_IsOK(res1)) {
31884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31885 }
31886 arg1 = reinterpret_cast< wxWindow * >(argp1);
31887 {
31888 PyThreadState* __tstate = wxPyBeginAllowThreads();
31889 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31890 wxPyEndAllowThreads(__tstate);
31891 if (PyErr_Occurred()) SWIG_fail;
31892 }
31893 resultobj = SWIG_From_int(static_cast< int >(result));
31894 return resultobj;
31895 fail:
31896 return NULL;
31897 }
31898
31899
31900 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31901 PyObject *resultobj = 0;
31902 wxWindow *arg1 = (wxWindow *) 0 ;
31903 int result;
31904 void *argp1 = 0 ;
31905 int res1 = 0 ;
31906 PyObject *swig_obj[1] ;
31907
31908 if (!args) SWIG_fail;
31909 swig_obj[0] = args;
31910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31911 if (!SWIG_IsOK(res1)) {
31912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31913 }
31914 arg1 = reinterpret_cast< wxWindow * >(argp1);
31915 {
31916 PyThreadState* __tstate = wxPyBeginAllowThreads();
31917 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31918 wxPyEndAllowThreads(__tstate);
31919 if (PyErr_Occurred()) SWIG_fail;
31920 }
31921 resultobj = SWIG_From_int(static_cast< int >(result));
31922 return resultobj;
31923 fail:
31924 return NULL;
31925 }
31926
31927
31928 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31929 PyObject *resultobj = 0;
31930 wxWindow *arg1 = (wxWindow *) 0 ;
31931 wxSize *arg2 = 0 ;
31932 void *argp1 = 0 ;
31933 int res1 = 0 ;
31934 wxSize temp2 ;
31935 PyObject * obj0 = 0 ;
31936 PyObject * obj1 = 0 ;
31937 char * kwnames[] = {
31938 (char *) "self",(char *) "size", NULL
31939 };
31940
31941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31943 if (!SWIG_IsOK(res1)) {
31944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31945 }
31946 arg1 = reinterpret_cast< wxWindow * >(argp1);
31947 {
31948 arg2 = &temp2;
31949 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31950 }
31951 {
31952 PyThreadState* __tstate = wxPyBeginAllowThreads();
31953 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31954 wxPyEndAllowThreads(__tstate);
31955 if (PyErr_Occurred()) SWIG_fail;
31956 }
31957 resultobj = SWIG_Py_Void();
31958 return resultobj;
31959 fail:
31960 return NULL;
31961 }
31962
31963
31964 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31965 PyObject *resultobj = 0;
31966 wxWindow *arg1 = (wxWindow *) 0 ;
31967 int arg2 ;
31968 int arg3 ;
31969 void *argp1 = 0 ;
31970 int res1 = 0 ;
31971 int val2 ;
31972 int ecode2 = 0 ;
31973 int val3 ;
31974 int ecode3 = 0 ;
31975 PyObject * obj0 = 0 ;
31976 PyObject * obj1 = 0 ;
31977 PyObject * obj2 = 0 ;
31978 char * kwnames[] = {
31979 (char *) "self",(char *) "w",(char *) "h", NULL
31980 };
31981
31982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31984 if (!SWIG_IsOK(res1)) {
31985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31986 }
31987 arg1 = reinterpret_cast< wxWindow * >(argp1);
31988 ecode2 = SWIG_AsVal_int(obj1, &val2);
31989 if (!SWIG_IsOK(ecode2)) {
31990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31991 }
31992 arg2 = static_cast< int >(val2);
31993 ecode3 = SWIG_AsVal_int(obj2, &val3);
31994 if (!SWIG_IsOK(ecode3)) {
31995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31996 }
31997 arg3 = static_cast< int >(val3);
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 (arg1)->SetVirtualSize(arg2,arg3);
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_Py_Void();
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32012 PyObject *resultobj = 0;
32013 wxWindow *arg1 = (wxWindow *) 0 ;
32014 wxSize result;
32015 void *argp1 = 0 ;
32016 int res1 = 0 ;
32017 PyObject *swig_obj[1] ;
32018
32019 if (!args) SWIG_fail;
32020 swig_obj[0] = args;
32021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32022 if (!SWIG_IsOK(res1)) {
32023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32024 }
32025 arg1 = reinterpret_cast< wxWindow * >(argp1);
32026 {
32027 PyThreadState* __tstate = wxPyBeginAllowThreads();
32028 result = ((wxWindow const *)arg1)->GetVirtualSize();
32029 wxPyEndAllowThreads(__tstate);
32030 if (PyErr_Occurred()) SWIG_fail;
32031 }
32032 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32033 return resultobj;
32034 fail:
32035 return NULL;
32036 }
32037
32038
32039 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32040 PyObject *resultobj = 0;
32041 wxWindow *arg1 = (wxWindow *) 0 ;
32042 int *arg2 = (int *) 0 ;
32043 int *arg3 = (int *) 0 ;
32044 void *argp1 = 0 ;
32045 int res1 = 0 ;
32046 int temp2 ;
32047 int res2 = SWIG_TMPOBJ ;
32048 int temp3 ;
32049 int res3 = SWIG_TMPOBJ ;
32050 PyObject *swig_obj[1] ;
32051
32052 arg2 = &temp2;
32053 arg3 = &temp3;
32054 if (!args) SWIG_fail;
32055 swig_obj[0] = args;
32056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32057 if (!SWIG_IsOK(res1)) {
32058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32059 }
32060 arg1 = reinterpret_cast< wxWindow * >(argp1);
32061 {
32062 PyThreadState* __tstate = wxPyBeginAllowThreads();
32063 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32064 wxPyEndAllowThreads(__tstate);
32065 if (PyErr_Occurred()) SWIG_fail;
32066 }
32067 resultobj = SWIG_Py_Void();
32068 if (SWIG_IsTmpObj(res2)) {
32069 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32070 } else {
32071 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32072 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32073 }
32074 if (SWIG_IsTmpObj(res3)) {
32075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32076 } else {
32077 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32079 }
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32087 PyObject *resultobj = 0;
32088 wxWindow *arg1 = (wxWindow *) 0 ;
32089 wxSize result;
32090 void *argp1 = 0 ;
32091 int res1 = 0 ;
32092 PyObject *swig_obj[1] ;
32093
32094 if (!args) SWIG_fail;
32095 swig_obj[0] = args;
32096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32097 if (!SWIG_IsOK(res1)) {
32098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32099 }
32100 arg1 = reinterpret_cast< wxWindow * >(argp1);
32101 {
32102 PyThreadState* __tstate = wxPyBeginAllowThreads();
32103 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32104 wxPyEndAllowThreads(__tstate);
32105 if (PyErr_Occurred()) SWIG_fail;
32106 }
32107 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32108 return resultobj;
32109 fail:
32110 return NULL;
32111 }
32112
32113
32114 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32115 PyObject *resultobj = 0;
32116 wxWindow *arg1 = (wxWindow *) 0 ;
32117 bool arg2 = (bool) true ;
32118 bool result;
32119 void *argp1 = 0 ;
32120 int res1 = 0 ;
32121 bool val2 ;
32122 int ecode2 = 0 ;
32123 PyObject * obj0 = 0 ;
32124 PyObject * obj1 = 0 ;
32125 char * kwnames[] = {
32126 (char *) "self",(char *) "show", NULL
32127 };
32128
32129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32131 if (!SWIG_IsOK(res1)) {
32132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32133 }
32134 arg1 = reinterpret_cast< wxWindow * >(argp1);
32135 if (obj1) {
32136 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32137 if (!SWIG_IsOK(ecode2)) {
32138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32139 }
32140 arg2 = static_cast< bool >(val2);
32141 }
32142 {
32143 PyThreadState* __tstate = wxPyBeginAllowThreads();
32144 result = (bool)(arg1)->Show(arg2);
32145 wxPyEndAllowThreads(__tstate);
32146 if (PyErr_Occurred()) SWIG_fail;
32147 }
32148 {
32149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32150 }
32151 return resultobj;
32152 fail:
32153 return NULL;
32154 }
32155
32156
32157 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32158 PyObject *resultobj = 0;
32159 wxWindow *arg1 = (wxWindow *) 0 ;
32160 bool result;
32161 void *argp1 = 0 ;
32162 int res1 = 0 ;
32163 PyObject *swig_obj[1] ;
32164
32165 if (!args) SWIG_fail;
32166 swig_obj[0] = args;
32167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32168 if (!SWIG_IsOK(res1)) {
32169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32170 }
32171 arg1 = reinterpret_cast< wxWindow * >(argp1);
32172 {
32173 PyThreadState* __tstate = wxPyBeginAllowThreads();
32174 result = (bool)(arg1)->Hide();
32175 wxPyEndAllowThreads(__tstate);
32176 if (PyErr_Occurred()) SWIG_fail;
32177 }
32178 {
32179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32180 }
32181 return resultobj;
32182 fail:
32183 return NULL;
32184 }
32185
32186
32187 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32188 PyObject *resultobj = 0;
32189 wxWindow *arg1 = (wxWindow *) 0 ;
32190 bool arg2 = (bool) true ;
32191 bool result;
32192 void *argp1 = 0 ;
32193 int res1 = 0 ;
32194 bool val2 ;
32195 int ecode2 = 0 ;
32196 PyObject * obj0 = 0 ;
32197 PyObject * obj1 = 0 ;
32198 char * kwnames[] = {
32199 (char *) "self",(char *) "enable", NULL
32200 };
32201
32202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32204 if (!SWIG_IsOK(res1)) {
32205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32206 }
32207 arg1 = reinterpret_cast< wxWindow * >(argp1);
32208 if (obj1) {
32209 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32210 if (!SWIG_IsOK(ecode2)) {
32211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32212 }
32213 arg2 = static_cast< bool >(val2);
32214 }
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (bool)(arg1)->Enable(arg2);
32218 wxPyEndAllowThreads(__tstate);
32219 if (PyErr_Occurred()) SWIG_fail;
32220 }
32221 {
32222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32223 }
32224 return resultobj;
32225 fail:
32226 return NULL;
32227 }
32228
32229
32230 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32231 PyObject *resultobj = 0;
32232 wxWindow *arg1 = (wxWindow *) 0 ;
32233 bool result;
32234 void *argp1 = 0 ;
32235 int res1 = 0 ;
32236 PyObject *swig_obj[1] ;
32237
32238 if (!args) SWIG_fail;
32239 swig_obj[0] = args;
32240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32241 if (!SWIG_IsOK(res1)) {
32242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32243 }
32244 arg1 = reinterpret_cast< wxWindow * >(argp1);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (bool)(arg1)->Disable();
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32253 }
32254 return resultobj;
32255 fail:
32256 return NULL;
32257 }
32258
32259
32260 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32261 PyObject *resultobj = 0;
32262 wxWindow *arg1 = (wxWindow *) 0 ;
32263 bool result;
32264 void *argp1 = 0 ;
32265 int res1 = 0 ;
32266 PyObject *swig_obj[1] ;
32267
32268 if (!args) SWIG_fail;
32269 swig_obj[0] = args;
32270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32271 if (!SWIG_IsOK(res1)) {
32272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32273 }
32274 arg1 = reinterpret_cast< wxWindow * >(argp1);
32275 {
32276 PyThreadState* __tstate = wxPyBeginAllowThreads();
32277 result = (bool)((wxWindow const *)arg1)->IsShown();
32278 wxPyEndAllowThreads(__tstate);
32279 if (PyErr_Occurred()) SWIG_fail;
32280 }
32281 {
32282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32283 }
32284 return resultobj;
32285 fail:
32286 return NULL;
32287 }
32288
32289
32290 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32291 PyObject *resultobj = 0;
32292 wxWindow *arg1 = (wxWindow *) 0 ;
32293 bool result;
32294 void *argp1 = 0 ;
32295 int res1 = 0 ;
32296 PyObject *swig_obj[1] ;
32297
32298 if (!args) SWIG_fail;
32299 swig_obj[0] = args;
32300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32301 if (!SWIG_IsOK(res1)) {
32302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32303 }
32304 arg1 = reinterpret_cast< wxWindow * >(argp1);
32305 {
32306 PyThreadState* __tstate = wxPyBeginAllowThreads();
32307 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32308 wxPyEndAllowThreads(__tstate);
32309 if (PyErr_Occurred()) SWIG_fail;
32310 }
32311 {
32312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32313 }
32314 return resultobj;
32315 fail:
32316 return NULL;
32317 }
32318
32319
32320 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32321 PyObject *resultobj = 0;
32322 wxWindow *arg1 = (wxWindow *) 0 ;
32323 long arg2 ;
32324 void *argp1 = 0 ;
32325 int res1 = 0 ;
32326 long val2 ;
32327 int ecode2 = 0 ;
32328 PyObject * obj0 = 0 ;
32329 PyObject * obj1 = 0 ;
32330 char * kwnames[] = {
32331 (char *) "self",(char *) "style", NULL
32332 };
32333
32334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32336 if (!SWIG_IsOK(res1)) {
32337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32338 }
32339 arg1 = reinterpret_cast< wxWindow * >(argp1);
32340 ecode2 = SWIG_AsVal_long(obj1, &val2);
32341 if (!SWIG_IsOK(ecode2)) {
32342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32343 }
32344 arg2 = static_cast< long >(val2);
32345 {
32346 PyThreadState* __tstate = wxPyBeginAllowThreads();
32347 (arg1)->SetWindowStyleFlag(arg2);
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 resultobj = SWIG_Py_Void();
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32359 PyObject *resultobj = 0;
32360 wxWindow *arg1 = (wxWindow *) 0 ;
32361 long result;
32362 void *argp1 = 0 ;
32363 int res1 = 0 ;
32364 PyObject *swig_obj[1] ;
32365
32366 if (!args) SWIG_fail;
32367 swig_obj[0] = args;
32368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32369 if (!SWIG_IsOK(res1)) {
32370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32371 }
32372 arg1 = reinterpret_cast< wxWindow * >(argp1);
32373 {
32374 PyThreadState* __tstate = wxPyBeginAllowThreads();
32375 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32376 wxPyEndAllowThreads(__tstate);
32377 if (PyErr_Occurred()) SWIG_fail;
32378 }
32379 resultobj = SWIG_From_long(static_cast< long >(result));
32380 return resultobj;
32381 fail:
32382 return NULL;
32383 }
32384
32385
32386 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32387 PyObject *resultobj = 0;
32388 wxWindow *arg1 = (wxWindow *) 0 ;
32389 int arg2 ;
32390 bool result;
32391 void *argp1 = 0 ;
32392 int res1 = 0 ;
32393 int val2 ;
32394 int ecode2 = 0 ;
32395 PyObject * obj0 = 0 ;
32396 PyObject * obj1 = 0 ;
32397 char * kwnames[] = {
32398 (char *) "self",(char *) "flag", NULL
32399 };
32400
32401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32403 if (!SWIG_IsOK(res1)) {
32404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32405 }
32406 arg1 = reinterpret_cast< wxWindow * >(argp1);
32407 ecode2 = SWIG_AsVal_int(obj1, &val2);
32408 if (!SWIG_IsOK(ecode2)) {
32409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32410 }
32411 arg2 = static_cast< int >(val2);
32412 {
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32415 wxPyEndAllowThreads(__tstate);
32416 if (PyErr_Occurred()) SWIG_fail;
32417 }
32418 {
32419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32420 }
32421 return resultobj;
32422 fail:
32423 return NULL;
32424 }
32425
32426
32427 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32428 PyObject *resultobj = 0;
32429 wxWindow *arg1 = (wxWindow *) 0 ;
32430 bool result;
32431 void *argp1 = 0 ;
32432 int res1 = 0 ;
32433 PyObject *swig_obj[1] ;
32434
32435 if (!args) SWIG_fail;
32436 swig_obj[0] = args;
32437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32440 }
32441 arg1 = reinterpret_cast< wxWindow * >(argp1);
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 result = (bool)((wxWindow const *)arg1)->IsRetained();
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 {
32449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32450 }
32451 return resultobj;
32452 fail:
32453 return NULL;
32454 }
32455
32456
32457 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32458 PyObject *resultobj = 0;
32459 wxWindow *arg1 = (wxWindow *) 0 ;
32460 long arg2 ;
32461 void *argp1 = 0 ;
32462 int res1 = 0 ;
32463 long val2 ;
32464 int ecode2 = 0 ;
32465 PyObject * obj0 = 0 ;
32466 PyObject * obj1 = 0 ;
32467 char * kwnames[] = {
32468 (char *) "self",(char *) "exStyle", NULL
32469 };
32470
32471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32473 if (!SWIG_IsOK(res1)) {
32474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32475 }
32476 arg1 = reinterpret_cast< wxWindow * >(argp1);
32477 ecode2 = SWIG_AsVal_long(obj1, &val2);
32478 if (!SWIG_IsOK(ecode2)) {
32479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32480 }
32481 arg2 = static_cast< long >(val2);
32482 {
32483 PyThreadState* __tstate = wxPyBeginAllowThreads();
32484 (arg1)->SetExtraStyle(arg2);
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 resultobj = SWIG_Py_Void();
32489 return resultobj;
32490 fail:
32491 return NULL;
32492 }
32493
32494
32495 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32496 PyObject *resultobj = 0;
32497 wxWindow *arg1 = (wxWindow *) 0 ;
32498 long result;
32499 void *argp1 = 0 ;
32500 int res1 = 0 ;
32501 PyObject *swig_obj[1] ;
32502
32503 if (!args) SWIG_fail;
32504 swig_obj[0] = args;
32505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32506 if (!SWIG_IsOK(res1)) {
32507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32508 }
32509 arg1 = reinterpret_cast< wxWindow * >(argp1);
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32513 wxPyEndAllowThreads(__tstate);
32514 if (PyErr_Occurred()) SWIG_fail;
32515 }
32516 resultobj = SWIG_From_long(static_cast< long >(result));
32517 return resultobj;
32518 fail:
32519 return NULL;
32520 }
32521
32522
32523 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32524 PyObject *resultobj = 0;
32525 wxWindow *arg1 = (wxWindow *) 0 ;
32526 bool arg2 = (bool) true ;
32527 void *argp1 = 0 ;
32528 int res1 = 0 ;
32529 bool val2 ;
32530 int ecode2 = 0 ;
32531 PyObject * obj0 = 0 ;
32532 PyObject * obj1 = 0 ;
32533 char * kwnames[] = {
32534 (char *) "self",(char *) "modal", NULL
32535 };
32536
32537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32539 if (!SWIG_IsOK(res1)) {
32540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32541 }
32542 arg1 = reinterpret_cast< wxWindow * >(argp1);
32543 if (obj1) {
32544 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32545 if (!SWIG_IsOK(ecode2)) {
32546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32547 }
32548 arg2 = static_cast< bool >(val2);
32549 }
32550 {
32551 PyThreadState* __tstate = wxPyBeginAllowThreads();
32552 (arg1)->MakeModal(arg2);
32553 wxPyEndAllowThreads(__tstate);
32554 if (PyErr_Occurred()) SWIG_fail;
32555 }
32556 resultobj = SWIG_Py_Void();
32557 return resultobj;
32558 fail:
32559 return NULL;
32560 }
32561
32562
32563 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32564 PyObject *resultobj = 0;
32565 wxWindow *arg1 = (wxWindow *) 0 ;
32566 bool arg2 ;
32567 void *argp1 = 0 ;
32568 int res1 = 0 ;
32569 bool val2 ;
32570 int ecode2 = 0 ;
32571 PyObject * obj0 = 0 ;
32572 PyObject * obj1 = 0 ;
32573 char * kwnames[] = {
32574 (char *) "self",(char *) "enableTheme", NULL
32575 };
32576
32577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32579 if (!SWIG_IsOK(res1)) {
32580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32581 }
32582 arg1 = reinterpret_cast< wxWindow * >(argp1);
32583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32584 if (!SWIG_IsOK(ecode2)) {
32585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32586 }
32587 arg2 = static_cast< bool >(val2);
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 (arg1)->SetThemeEnabled(arg2);
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_Py_Void();
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32602 PyObject *resultobj = 0;
32603 wxWindow *arg1 = (wxWindow *) 0 ;
32604 bool result;
32605 void *argp1 = 0 ;
32606 int res1 = 0 ;
32607 PyObject *swig_obj[1] ;
32608
32609 if (!args) SWIG_fail;
32610 swig_obj[0] = args;
32611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32612 if (!SWIG_IsOK(res1)) {
32613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32614 }
32615 arg1 = reinterpret_cast< wxWindow * >(argp1);
32616 {
32617 PyThreadState* __tstate = wxPyBeginAllowThreads();
32618 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32619 wxPyEndAllowThreads(__tstate);
32620 if (PyErr_Occurred()) SWIG_fail;
32621 }
32622 {
32623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32624 }
32625 return resultobj;
32626 fail:
32627 return NULL;
32628 }
32629
32630
32631 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32632 PyObject *resultobj = 0;
32633 wxWindow *arg1 = (wxWindow *) 0 ;
32634 void *argp1 = 0 ;
32635 int res1 = 0 ;
32636 PyObject *swig_obj[1] ;
32637
32638 if (!args) SWIG_fail;
32639 swig_obj[0] = args;
32640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32641 if (!SWIG_IsOK(res1)) {
32642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32643 }
32644 arg1 = reinterpret_cast< wxWindow * >(argp1);
32645 {
32646 PyThreadState* __tstate = wxPyBeginAllowThreads();
32647 (arg1)->SetFocus();
32648 wxPyEndAllowThreads(__tstate);
32649 if (PyErr_Occurred()) SWIG_fail;
32650 }
32651 resultobj = SWIG_Py_Void();
32652 return resultobj;
32653 fail:
32654 return NULL;
32655 }
32656
32657
32658 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32659 PyObject *resultobj = 0;
32660 wxWindow *arg1 = (wxWindow *) 0 ;
32661 void *argp1 = 0 ;
32662 int res1 = 0 ;
32663 PyObject *swig_obj[1] ;
32664
32665 if (!args) SWIG_fail;
32666 swig_obj[0] = args;
32667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32668 if (!SWIG_IsOK(res1)) {
32669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32670 }
32671 arg1 = reinterpret_cast< wxWindow * >(argp1);
32672 {
32673 PyThreadState* __tstate = wxPyBeginAllowThreads();
32674 (arg1)->SetFocusFromKbd();
32675 wxPyEndAllowThreads(__tstate);
32676 if (PyErr_Occurred()) SWIG_fail;
32677 }
32678 resultobj = SWIG_Py_Void();
32679 return resultobj;
32680 fail:
32681 return NULL;
32682 }
32683
32684
32685 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32686 PyObject *resultobj = 0;
32687 wxWindow *result = 0 ;
32688
32689 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32690 {
32691 if (!wxPyCheckForApp()) SWIG_fail;
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 result = (wxWindow *)wxWindow::FindFocus();
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 {
32698 resultobj = wxPyMake_wxObject(result, 0);
32699 }
32700 return resultobj;
32701 fail:
32702 return NULL;
32703 }
32704
32705
32706 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32707 PyObject *resultobj = 0;
32708 wxWindow *arg1 = (wxWindow *) 0 ;
32709 bool result;
32710 void *argp1 = 0 ;
32711 int res1 = 0 ;
32712 PyObject *swig_obj[1] ;
32713
32714 if (!args) SWIG_fail;
32715 swig_obj[0] = args;
32716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32717 if (!SWIG_IsOK(res1)) {
32718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32719 }
32720 arg1 = reinterpret_cast< wxWindow * >(argp1);
32721 {
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32724 wxPyEndAllowThreads(__tstate);
32725 if (PyErr_Occurred()) SWIG_fail;
32726 }
32727 {
32728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32729 }
32730 return resultobj;
32731 fail:
32732 return NULL;
32733 }
32734
32735
32736 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32737 PyObject *resultobj = 0;
32738 wxWindow *arg1 = (wxWindow *) 0 ;
32739 bool result;
32740 void *argp1 = 0 ;
32741 int res1 = 0 ;
32742 PyObject *swig_obj[1] ;
32743
32744 if (!args) SWIG_fail;
32745 swig_obj[0] = args;
32746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32747 if (!SWIG_IsOK(res1)) {
32748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32749 }
32750 arg1 = reinterpret_cast< wxWindow * >(argp1);
32751 {
32752 PyThreadState* __tstate = wxPyBeginAllowThreads();
32753 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32754 wxPyEndAllowThreads(__tstate);
32755 if (PyErr_Occurred()) SWIG_fail;
32756 }
32757 {
32758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32759 }
32760 return resultobj;
32761 fail:
32762 return NULL;
32763 }
32764
32765
32766 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32767 PyObject *resultobj = 0;
32768 wxWindow *arg1 = (wxWindow *) 0 ;
32769 wxWindow *result = 0 ;
32770 void *argp1 = 0 ;
32771 int res1 = 0 ;
32772 PyObject *swig_obj[1] ;
32773
32774 if (!args) SWIG_fail;
32775 swig_obj[0] = args;
32776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32777 if (!SWIG_IsOK(res1)) {
32778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32779 }
32780 arg1 = reinterpret_cast< wxWindow * >(argp1);
32781 {
32782 PyThreadState* __tstate = wxPyBeginAllowThreads();
32783 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32784 wxPyEndAllowThreads(__tstate);
32785 if (PyErr_Occurred()) SWIG_fail;
32786 }
32787 {
32788 resultobj = wxPyMake_wxObject(result, 0);
32789 }
32790 return resultobj;
32791 fail:
32792 return NULL;
32793 }
32794
32795
32796 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32797 PyObject *resultobj = 0;
32798 wxWindow *arg1 = (wxWindow *) 0 ;
32799 wxWindow *arg2 = (wxWindow *) 0 ;
32800 wxWindow *result = 0 ;
32801 void *argp1 = 0 ;
32802 int res1 = 0 ;
32803 void *argp2 = 0 ;
32804 int res2 = 0 ;
32805 PyObject * obj0 = 0 ;
32806 PyObject * obj1 = 0 ;
32807 char * kwnames[] = {
32808 (char *) "self",(char *) "child", NULL
32809 };
32810
32811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32813 if (!SWIG_IsOK(res1)) {
32814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32815 }
32816 arg1 = reinterpret_cast< wxWindow * >(argp1);
32817 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32818 if (!SWIG_IsOK(res2)) {
32819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32820 }
32821 arg2 = reinterpret_cast< wxWindow * >(argp2);
32822 {
32823 PyThreadState* __tstate = wxPyBeginAllowThreads();
32824 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32825 wxPyEndAllowThreads(__tstate);
32826 if (PyErr_Occurred()) SWIG_fail;
32827 }
32828 {
32829 resultobj = wxPyMake_wxObject(result, 0);
32830 }
32831 return resultobj;
32832 fail:
32833 return NULL;
32834 }
32835
32836
32837 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32838 PyObject *resultobj = 0;
32839 wxWindow *arg1 = (wxWindow *) 0 ;
32840 wxWindow *arg2 = (wxWindow *) 0 ;
32841 void *argp1 = 0 ;
32842 int res1 = 0 ;
32843 void *argp2 = 0 ;
32844 int res2 = 0 ;
32845 PyObject * obj0 = 0 ;
32846 PyObject * obj1 = 0 ;
32847 char * kwnames[] = {
32848 (char *) "self",(char *) "win", NULL
32849 };
32850
32851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32853 if (!SWIG_IsOK(res1)) {
32854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32855 }
32856 arg1 = reinterpret_cast< wxWindow * >(argp1);
32857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32858 if (!SWIG_IsOK(res2)) {
32859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32860 }
32861 arg2 = reinterpret_cast< wxWindow * >(argp2);
32862 {
32863 PyThreadState* __tstate = wxPyBeginAllowThreads();
32864 (arg1)->SetTmpDefaultItem(arg2);
32865 wxPyEndAllowThreads(__tstate);
32866 if (PyErr_Occurred()) SWIG_fail;
32867 }
32868 resultobj = SWIG_Py_Void();
32869 return resultobj;
32870 fail:
32871 return NULL;
32872 }
32873
32874
32875 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32876 PyObject *resultobj = 0;
32877 wxWindow *arg1 = (wxWindow *) 0 ;
32878 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32879 bool result;
32880 void *argp1 = 0 ;
32881 int res1 = 0 ;
32882 int val2 ;
32883 int ecode2 = 0 ;
32884 PyObject * obj0 = 0 ;
32885 PyObject * obj1 = 0 ;
32886 char * kwnames[] = {
32887 (char *) "self",(char *) "flags", NULL
32888 };
32889
32890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32892 if (!SWIG_IsOK(res1)) {
32893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32894 }
32895 arg1 = reinterpret_cast< wxWindow * >(argp1);
32896 if (obj1) {
32897 ecode2 = SWIG_AsVal_int(obj1, &val2);
32898 if (!SWIG_IsOK(ecode2)) {
32899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32900 }
32901 arg2 = static_cast< int >(val2);
32902 }
32903 {
32904 PyThreadState* __tstate = wxPyBeginAllowThreads();
32905 result = (bool)(arg1)->Navigate(arg2);
32906 wxPyEndAllowThreads(__tstate);
32907 if (PyErr_Occurred()) SWIG_fail;
32908 }
32909 {
32910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32911 }
32912 return resultobj;
32913 fail:
32914 return NULL;
32915 }
32916
32917
32918 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32919 PyObject *resultobj = 0;
32920 wxWindow *arg1 = (wxWindow *) 0 ;
32921 wxWindow *arg2 = (wxWindow *) 0 ;
32922 void *argp1 = 0 ;
32923 int res1 = 0 ;
32924 void *argp2 = 0 ;
32925 int res2 = 0 ;
32926 PyObject * obj0 = 0 ;
32927 PyObject * obj1 = 0 ;
32928 char * kwnames[] = {
32929 (char *) "self",(char *) "win", NULL
32930 };
32931
32932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32934 if (!SWIG_IsOK(res1)) {
32935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32936 }
32937 arg1 = reinterpret_cast< wxWindow * >(argp1);
32938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32939 if (!SWIG_IsOK(res2)) {
32940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32941 }
32942 arg2 = reinterpret_cast< wxWindow * >(argp2);
32943 {
32944 PyThreadState* __tstate = wxPyBeginAllowThreads();
32945 (arg1)->MoveAfterInTabOrder(arg2);
32946 wxPyEndAllowThreads(__tstate);
32947 if (PyErr_Occurred()) SWIG_fail;
32948 }
32949 resultobj = SWIG_Py_Void();
32950 return resultobj;
32951 fail:
32952 return NULL;
32953 }
32954
32955
32956 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32957 PyObject *resultobj = 0;
32958 wxWindow *arg1 = (wxWindow *) 0 ;
32959 wxWindow *arg2 = (wxWindow *) 0 ;
32960 void *argp1 = 0 ;
32961 int res1 = 0 ;
32962 void *argp2 = 0 ;
32963 int res2 = 0 ;
32964 PyObject * obj0 = 0 ;
32965 PyObject * obj1 = 0 ;
32966 char * kwnames[] = {
32967 (char *) "self",(char *) "win", NULL
32968 };
32969
32970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32972 if (!SWIG_IsOK(res1)) {
32973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32974 }
32975 arg1 = reinterpret_cast< wxWindow * >(argp1);
32976 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32977 if (!SWIG_IsOK(res2)) {
32978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32979 }
32980 arg2 = reinterpret_cast< wxWindow * >(argp2);
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 (arg1)->MoveBeforeInTabOrder(arg2);
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 resultobj = SWIG_Py_Void();
32988 return resultobj;
32989 fail:
32990 return NULL;
32991 }
32992
32993
32994 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32995 PyObject *resultobj = 0;
32996 wxWindow *arg1 = (wxWindow *) 0 ;
32997 PyObject *result = 0 ;
32998 void *argp1 = 0 ;
32999 int res1 = 0 ;
33000 PyObject *swig_obj[1] ;
33001
33002 if (!args) SWIG_fail;
33003 swig_obj[0] = args;
33004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33005 if (!SWIG_IsOK(res1)) {
33006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33007 }
33008 arg1 = reinterpret_cast< wxWindow * >(argp1);
33009 {
33010 PyThreadState* __tstate = wxPyBeginAllowThreads();
33011 result = (PyObject *)wxWindow_GetChildren(arg1);
33012 wxPyEndAllowThreads(__tstate);
33013 if (PyErr_Occurred()) SWIG_fail;
33014 }
33015 resultobj = result;
33016 return resultobj;
33017 fail:
33018 return NULL;
33019 }
33020
33021
33022 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33023 PyObject *resultobj = 0;
33024 wxWindow *arg1 = (wxWindow *) 0 ;
33025 wxWindow *result = 0 ;
33026 void *argp1 = 0 ;
33027 int res1 = 0 ;
33028 PyObject *swig_obj[1] ;
33029
33030 if (!args) SWIG_fail;
33031 swig_obj[0] = args;
33032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33035 }
33036 arg1 = reinterpret_cast< wxWindow * >(argp1);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 {
33044 resultobj = wxPyMake_wxObject(result, 0);
33045 }
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33053 PyObject *resultobj = 0;
33054 wxWindow *arg1 = (wxWindow *) 0 ;
33055 wxWindow *result = 0 ;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 PyObject *swig_obj[1] ;
33059
33060 if (!args) SWIG_fail;
33061 swig_obj[0] = args;
33062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33063 if (!SWIG_IsOK(res1)) {
33064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33065 }
33066 arg1 = reinterpret_cast< wxWindow * >(argp1);
33067 {
33068 PyThreadState* __tstate = wxPyBeginAllowThreads();
33069 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33070 wxPyEndAllowThreads(__tstate);
33071 if (PyErr_Occurred()) SWIG_fail;
33072 }
33073 {
33074 resultobj = wxPyMake_wxObject(result, 0);
33075 }
33076 return resultobj;
33077 fail:
33078 return NULL;
33079 }
33080
33081
33082 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33083 PyObject *resultobj = 0;
33084 wxWindow *arg1 = (wxWindow *) 0 ;
33085 bool result;
33086 void *argp1 = 0 ;
33087 int res1 = 0 ;
33088 PyObject *swig_obj[1] ;
33089
33090 if (!args) SWIG_fail;
33091 swig_obj[0] = args;
33092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33093 if (!SWIG_IsOK(res1)) {
33094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33095 }
33096 arg1 = reinterpret_cast< wxWindow * >(argp1);
33097 {
33098 PyThreadState* __tstate = wxPyBeginAllowThreads();
33099 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33100 wxPyEndAllowThreads(__tstate);
33101 if (PyErr_Occurred()) SWIG_fail;
33102 }
33103 {
33104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33105 }
33106 return resultobj;
33107 fail:
33108 return NULL;
33109 }
33110
33111
33112 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33113 PyObject *resultobj = 0;
33114 wxWindow *arg1 = (wxWindow *) 0 ;
33115 wxWindow *arg2 = (wxWindow *) 0 ;
33116 bool result;
33117 void *argp1 = 0 ;
33118 int res1 = 0 ;
33119 void *argp2 = 0 ;
33120 int res2 = 0 ;
33121 PyObject * obj0 = 0 ;
33122 PyObject * obj1 = 0 ;
33123 char * kwnames[] = {
33124 (char *) "self",(char *) "newParent", NULL
33125 };
33126
33127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33129 if (!SWIG_IsOK(res1)) {
33130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33131 }
33132 arg1 = reinterpret_cast< wxWindow * >(argp1);
33133 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33134 if (!SWIG_IsOK(res2)) {
33135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33136 }
33137 arg2 = reinterpret_cast< wxWindow * >(argp2);
33138 {
33139 PyThreadState* __tstate = wxPyBeginAllowThreads();
33140 result = (bool)(arg1)->Reparent(arg2);
33141 wxPyEndAllowThreads(__tstate);
33142 if (PyErr_Occurred()) SWIG_fail;
33143 }
33144 {
33145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33146 }
33147 return resultobj;
33148 fail:
33149 return NULL;
33150 }
33151
33152
33153 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33154 PyObject *resultobj = 0;
33155 wxWindow *arg1 = (wxWindow *) 0 ;
33156 wxWindow *arg2 = (wxWindow *) 0 ;
33157 void *argp1 = 0 ;
33158 int res1 = 0 ;
33159 void *argp2 = 0 ;
33160 int res2 = 0 ;
33161 PyObject * obj0 = 0 ;
33162 PyObject * obj1 = 0 ;
33163 char * kwnames[] = {
33164 (char *) "self",(char *) "child", NULL
33165 };
33166
33167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33169 if (!SWIG_IsOK(res1)) {
33170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33171 }
33172 arg1 = reinterpret_cast< wxWindow * >(argp1);
33173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33174 if (!SWIG_IsOK(res2)) {
33175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33176 }
33177 arg2 = reinterpret_cast< wxWindow * >(argp2);
33178 {
33179 PyThreadState* __tstate = wxPyBeginAllowThreads();
33180 (arg1)->AddChild(arg2);
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 resultobj = SWIG_Py_Void();
33185 return resultobj;
33186 fail:
33187 return NULL;
33188 }
33189
33190
33191 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33192 PyObject *resultobj = 0;
33193 wxWindow *arg1 = (wxWindow *) 0 ;
33194 wxWindow *arg2 = (wxWindow *) 0 ;
33195 void *argp1 = 0 ;
33196 int res1 = 0 ;
33197 void *argp2 = 0 ;
33198 int res2 = 0 ;
33199 PyObject * obj0 = 0 ;
33200 PyObject * obj1 = 0 ;
33201 char * kwnames[] = {
33202 (char *) "self",(char *) "child", NULL
33203 };
33204
33205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33207 if (!SWIG_IsOK(res1)) {
33208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33209 }
33210 arg1 = reinterpret_cast< wxWindow * >(argp1);
33211 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33212 if (!SWIG_IsOK(res2)) {
33213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33214 }
33215 arg2 = reinterpret_cast< wxWindow * >(argp2);
33216 {
33217 PyThreadState* __tstate = wxPyBeginAllowThreads();
33218 (arg1)->RemoveChild(arg2);
33219 wxPyEndAllowThreads(__tstate);
33220 if (PyErr_Occurred()) SWIG_fail;
33221 }
33222 resultobj = SWIG_Py_Void();
33223 return resultobj;
33224 fail:
33225 return NULL;
33226 }
33227
33228
33229 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33230 PyObject *resultobj = 0;
33231 wxWindow *arg1 = (wxWindow *) 0 ;
33232 bool arg2 ;
33233 void *argp1 = 0 ;
33234 int res1 = 0 ;
33235 bool val2 ;
33236 int ecode2 = 0 ;
33237 PyObject * obj0 = 0 ;
33238 PyObject * obj1 = 0 ;
33239 char * kwnames[] = {
33240 (char *) "self",(char *) "on", NULL
33241 };
33242
33243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33245 if (!SWIG_IsOK(res1)) {
33246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33247 }
33248 arg1 = reinterpret_cast< wxWindow * >(argp1);
33249 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33250 if (!SWIG_IsOK(ecode2)) {
33251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33252 }
33253 arg2 = static_cast< bool >(val2);
33254 {
33255 PyThreadState* __tstate = wxPyBeginAllowThreads();
33256 wxWindow_SetDoubleBuffered(arg1,arg2);
33257 wxPyEndAllowThreads(__tstate);
33258 if (PyErr_Occurred()) SWIG_fail;
33259 }
33260 resultobj = SWIG_Py_Void();
33261 return resultobj;
33262 fail:
33263 return NULL;
33264 }
33265
33266
33267 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33268 PyObject *resultobj = 0;
33269 wxWindow *arg1 = (wxWindow *) 0 ;
33270 long arg2 ;
33271 wxWindow *result = 0 ;
33272 void *argp1 = 0 ;
33273 int res1 = 0 ;
33274 long val2 ;
33275 int ecode2 = 0 ;
33276 PyObject * obj0 = 0 ;
33277 PyObject * obj1 = 0 ;
33278 char * kwnames[] = {
33279 (char *) "self",(char *) "winid", NULL
33280 };
33281
33282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33284 if (!SWIG_IsOK(res1)) {
33285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33286 }
33287 arg1 = reinterpret_cast< wxWindow * >(argp1);
33288 ecode2 = SWIG_AsVal_long(obj1, &val2);
33289 if (!SWIG_IsOK(ecode2)) {
33290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33291 }
33292 arg2 = static_cast< long >(val2);
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 result = (wxWindow *)(arg1)->FindWindow(arg2);
33296 wxPyEndAllowThreads(__tstate);
33297 if (PyErr_Occurred()) SWIG_fail;
33298 }
33299 {
33300 resultobj = wxPyMake_wxObject(result, 0);
33301 }
33302 return resultobj;
33303 fail:
33304 return NULL;
33305 }
33306
33307
33308 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33309 PyObject *resultobj = 0;
33310 wxWindow *arg1 = (wxWindow *) 0 ;
33311 wxString *arg2 = 0 ;
33312 wxWindow *result = 0 ;
33313 void *argp1 = 0 ;
33314 int res1 = 0 ;
33315 bool temp2 = false ;
33316 PyObject * obj0 = 0 ;
33317 PyObject * obj1 = 0 ;
33318 char * kwnames[] = {
33319 (char *) "self",(char *) "name", NULL
33320 };
33321
33322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33324 if (!SWIG_IsOK(res1)) {
33325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33326 }
33327 arg1 = reinterpret_cast< wxWindow * >(argp1);
33328 {
33329 arg2 = wxString_in_helper(obj1);
33330 if (arg2 == NULL) SWIG_fail;
33331 temp2 = true;
33332 }
33333 {
33334 PyThreadState* __tstate = wxPyBeginAllowThreads();
33335 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33336 wxPyEndAllowThreads(__tstate);
33337 if (PyErr_Occurred()) SWIG_fail;
33338 }
33339 {
33340 resultobj = wxPyMake_wxObject(result, 0);
33341 }
33342 {
33343 if (temp2)
33344 delete arg2;
33345 }
33346 return resultobj;
33347 fail:
33348 {
33349 if (temp2)
33350 delete arg2;
33351 }
33352 return NULL;
33353 }
33354
33355
33356 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33357 PyObject *resultobj = 0;
33358 wxWindow *arg1 = (wxWindow *) 0 ;
33359 wxEvtHandler *result = 0 ;
33360 void *argp1 = 0 ;
33361 int res1 = 0 ;
33362 PyObject *swig_obj[1] ;
33363
33364 if (!args) SWIG_fail;
33365 swig_obj[0] = args;
33366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33367 if (!SWIG_IsOK(res1)) {
33368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33369 }
33370 arg1 = reinterpret_cast< wxWindow * >(argp1);
33371 {
33372 PyThreadState* __tstate = wxPyBeginAllowThreads();
33373 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33374 wxPyEndAllowThreads(__tstate);
33375 if (PyErr_Occurred()) SWIG_fail;
33376 }
33377 {
33378 resultobj = wxPyMake_wxObject(result, 0);
33379 }
33380 return resultobj;
33381 fail:
33382 return NULL;
33383 }
33384
33385
33386 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33387 PyObject *resultobj = 0;
33388 wxWindow *arg1 = (wxWindow *) 0 ;
33389 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33390 void *argp1 = 0 ;
33391 int res1 = 0 ;
33392 void *argp2 = 0 ;
33393 int res2 = 0 ;
33394 PyObject * obj0 = 0 ;
33395 PyObject * obj1 = 0 ;
33396 char * kwnames[] = {
33397 (char *) "self",(char *) "handler", NULL
33398 };
33399
33400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33402 if (!SWIG_IsOK(res1)) {
33403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33404 }
33405 arg1 = reinterpret_cast< wxWindow * >(argp1);
33406 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33407 if (!SWIG_IsOK(res2)) {
33408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33409 }
33410 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33411 {
33412 PyThreadState* __tstate = wxPyBeginAllowThreads();
33413 (arg1)->SetEventHandler(arg2);
33414 wxPyEndAllowThreads(__tstate);
33415 if (PyErr_Occurred()) SWIG_fail;
33416 }
33417 resultobj = SWIG_Py_Void();
33418 return resultobj;
33419 fail:
33420 return NULL;
33421 }
33422
33423
33424 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33425 PyObject *resultobj = 0;
33426 wxWindow *arg1 = (wxWindow *) 0 ;
33427 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33428 void *argp1 = 0 ;
33429 int res1 = 0 ;
33430 void *argp2 = 0 ;
33431 int res2 = 0 ;
33432 PyObject * obj0 = 0 ;
33433 PyObject * obj1 = 0 ;
33434 char * kwnames[] = {
33435 (char *) "self",(char *) "handler", NULL
33436 };
33437
33438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33440 if (!SWIG_IsOK(res1)) {
33441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33442 }
33443 arg1 = reinterpret_cast< wxWindow * >(argp1);
33444 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33445 if (!SWIG_IsOK(res2)) {
33446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33447 }
33448 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33449 {
33450 PyThreadState* __tstate = wxPyBeginAllowThreads();
33451 (arg1)->PushEventHandler(arg2);
33452 wxPyEndAllowThreads(__tstate);
33453 if (PyErr_Occurred()) SWIG_fail;
33454 }
33455 resultobj = SWIG_Py_Void();
33456 return resultobj;
33457 fail:
33458 return NULL;
33459 }
33460
33461
33462 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33463 PyObject *resultobj = 0;
33464 wxWindow *arg1 = (wxWindow *) 0 ;
33465 bool arg2 = (bool) false ;
33466 wxEvtHandler *result = 0 ;
33467 void *argp1 = 0 ;
33468 int res1 = 0 ;
33469 bool val2 ;
33470 int ecode2 = 0 ;
33471 PyObject * obj0 = 0 ;
33472 PyObject * obj1 = 0 ;
33473 char * kwnames[] = {
33474 (char *) "self",(char *) "deleteHandler", NULL
33475 };
33476
33477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33479 if (!SWIG_IsOK(res1)) {
33480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33481 }
33482 arg1 = reinterpret_cast< wxWindow * >(argp1);
33483 if (obj1) {
33484 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33485 if (!SWIG_IsOK(ecode2)) {
33486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33487 }
33488 arg2 = static_cast< bool >(val2);
33489 }
33490 {
33491 PyThreadState* __tstate = wxPyBeginAllowThreads();
33492 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33493 wxPyEndAllowThreads(__tstate);
33494 if (PyErr_Occurred()) SWIG_fail;
33495 }
33496 {
33497 resultobj = wxPyMake_wxObject(result, 0);
33498 }
33499 return resultobj;
33500 fail:
33501 return NULL;
33502 }
33503
33504
33505 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33506 PyObject *resultobj = 0;
33507 wxWindow *arg1 = (wxWindow *) 0 ;
33508 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33509 bool result;
33510 void *argp1 = 0 ;
33511 int res1 = 0 ;
33512 void *argp2 = 0 ;
33513 int res2 = 0 ;
33514 PyObject * obj0 = 0 ;
33515 PyObject * obj1 = 0 ;
33516 char * kwnames[] = {
33517 (char *) "self",(char *) "handler", NULL
33518 };
33519
33520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33522 if (!SWIG_IsOK(res1)) {
33523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33524 }
33525 arg1 = reinterpret_cast< wxWindow * >(argp1);
33526 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33527 if (!SWIG_IsOK(res2)) {
33528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33529 }
33530 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33531 {
33532 PyThreadState* __tstate = wxPyBeginAllowThreads();
33533 result = (bool)(arg1)->RemoveEventHandler(arg2);
33534 wxPyEndAllowThreads(__tstate);
33535 if (PyErr_Occurred()) SWIG_fail;
33536 }
33537 {
33538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33539 }
33540 return resultobj;
33541 fail:
33542 return NULL;
33543 }
33544
33545
33546 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33547 PyObject *resultobj = 0;
33548 wxWindow *arg1 = (wxWindow *) 0 ;
33549 wxValidator *arg2 = 0 ;
33550 void *argp1 = 0 ;
33551 int res1 = 0 ;
33552 void *argp2 = 0 ;
33553 int res2 = 0 ;
33554 PyObject * obj0 = 0 ;
33555 PyObject * obj1 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "self",(char *) "validator", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33562 if (!SWIG_IsOK(res1)) {
33563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33564 }
33565 arg1 = reinterpret_cast< wxWindow * >(argp1);
33566 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33567 if (!SWIG_IsOK(res2)) {
33568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33569 }
33570 if (!argp2) {
33571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33572 }
33573 arg2 = reinterpret_cast< wxValidator * >(argp2);
33574 {
33575 PyThreadState* __tstate = wxPyBeginAllowThreads();
33576 (arg1)->SetValidator((wxValidator const &)*arg2);
33577 wxPyEndAllowThreads(__tstate);
33578 if (PyErr_Occurred()) SWIG_fail;
33579 }
33580 resultobj = SWIG_Py_Void();
33581 return resultobj;
33582 fail:
33583 return NULL;
33584 }
33585
33586
33587 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33588 PyObject *resultobj = 0;
33589 wxWindow *arg1 = (wxWindow *) 0 ;
33590 wxValidator *result = 0 ;
33591 void *argp1 = 0 ;
33592 int res1 = 0 ;
33593 PyObject *swig_obj[1] ;
33594
33595 if (!args) SWIG_fail;
33596 swig_obj[0] = args;
33597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33598 if (!SWIG_IsOK(res1)) {
33599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33600 }
33601 arg1 = reinterpret_cast< wxWindow * >(argp1);
33602 {
33603 PyThreadState* __tstate = wxPyBeginAllowThreads();
33604 result = (wxValidator *)(arg1)->GetValidator();
33605 wxPyEndAllowThreads(__tstate);
33606 if (PyErr_Occurred()) SWIG_fail;
33607 }
33608 {
33609 resultobj = wxPyMake_wxObject(result, (bool)0);
33610 }
33611 return resultobj;
33612 fail:
33613 return NULL;
33614 }
33615
33616
33617 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33618 PyObject *resultobj = 0;
33619 wxWindow *arg1 = (wxWindow *) 0 ;
33620 bool result;
33621 void *argp1 = 0 ;
33622 int res1 = 0 ;
33623 PyObject *swig_obj[1] ;
33624
33625 if (!args) SWIG_fail;
33626 swig_obj[0] = args;
33627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33628 if (!SWIG_IsOK(res1)) {
33629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33630 }
33631 arg1 = reinterpret_cast< wxWindow * >(argp1);
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 result = (bool)(arg1)->Validate();
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 {
33639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33640 }
33641 return resultobj;
33642 fail:
33643 return NULL;
33644 }
33645
33646
33647 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33648 PyObject *resultobj = 0;
33649 wxWindow *arg1 = (wxWindow *) 0 ;
33650 bool result;
33651 void *argp1 = 0 ;
33652 int res1 = 0 ;
33653 PyObject *swig_obj[1] ;
33654
33655 if (!args) SWIG_fail;
33656 swig_obj[0] = args;
33657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33658 if (!SWIG_IsOK(res1)) {
33659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33660 }
33661 arg1 = reinterpret_cast< wxWindow * >(argp1);
33662 {
33663 PyThreadState* __tstate = wxPyBeginAllowThreads();
33664 result = (bool)(arg1)->TransferDataToWindow();
33665 wxPyEndAllowThreads(__tstate);
33666 if (PyErr_Occurred()) SWIG_fail;
33667 }
33668 {
33669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33670 }
33671 return resultobj;
33672 fail:
33673 return NULL;
33674 }
33675
33676
33677 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33678 PyObject *resultobj = 0;
33679 wxWindow *arg1 = (wxWindow *) 0 ;
33680 bool result;
33681 void *argp1 = 0 ;
33682 int res1 = 0 ;
33683 PyObject *swig_obj[1] ;
33684
33685 if (!args) SWIG_fail;
33686 swig_obj[0] = args;
33687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33688 if (!SWIG_IsOK(res1)) {
33689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33690 }
33691 arg1 = reinterpret_cast< wxWindow * >(argp1);
33692 {
33693 PyThreadState* __tstate = wxPyBeginAllowThreads();
33694 result = (bool)(arg1)->TransferDataFromWindow();
33695 wxPyEndAllowThreads(__tstate);
33696 if (PyErr_Occurred()) SWIG_fail;
33697 }
33698 {
33699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33700 }
33701 return resultobj;
33702 fail:
33703 return NULL;
33704 }
33705
33706
33707 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33708 PyObject *resultobj = 0;
33709 wxWindow *arg1 = (wxWindow *) 0 ;
33710 void *argp1 = 0 ;
33711 int res1 = 0 ;
33712 PyObject *swig_obj[1] ;
33713
33714 if (!args) SWIG_fail;
33715 swig_obj[0] = args;
33716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33717 if (!SWIG_IsOK(res1)) {
33718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33719 }
33720 arg1 = reinterpret_cast< wxWindow * >(argp1);
33721 {
33722 PyThreadState* __tstate = wxPyBeginAllowThreads();
33723 (arg1)->InitDialog();
33724 wxPyEndAllowThreads(__tstate);
33725 if (PyErr_Occurred()) SWIG_fail;
33726 }
33727 resultobj = SWIG_Py_Void();
33728 return resultobj;
33729 fail:
33730 return NULL;
33731 }
33732
33733
33734 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33735 PyObject *resultobj = 0;
33736 wxWindow *arg1 = (wxWindow *) 0 ;
33737 wxAcceleratorTable *arg2 = 0 ;
33738 void *argp1 = 0 ;
33739 int res1 = 0 ;
33740 void *argp2 = 0 ;
33741 int res2 = 0 ;
33742 PyObject * obj0 = 0 ;
33743 PyObject * obj1 = 0 ;
33744 char * kwnames[] = {
33745 (char *) "self",(char *) "accel", NULL
33746 };
33747
33748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33750 if (!SWIG_IsOK(res1)) {
33751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33752 }
33753 arg1 = reinterpret_cast< wxWindow * >(argp1);
33754 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33755 if (!SWIG_IsOK(res2)) {
33756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33757 }
33758 if (!argp2) {
33759 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33760 }
33761 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33762 {
33763 PyThreadState* __tstate = wxPyBeginAllowThreads();
33764 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33765 wxPyEndAllowThreads(__tstate);
33766 if (PyErr_Occurred()) SWIG_fail;
33767 }
33768 resultobj = SWIG_Py_Void();
33769 return resultobj;
33770 fail:
33771 return NULL;
33772 }
33773
33774
33775 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33776 PyObject *resultobj = 0;
33777 wxWindow *arg1 = (wxWindow *) 0 ;
33778 wxAcceleratorTable *result = 0 ;
33779 void *argp1 = 0 ;
33780 int res1 = 0 ;
33781 PyObject *swig_obj[1] ;
33782
33783 if (!args) SWIG_fail;
33784 swig_obj[0] = args;
33785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33786 if (!SWIG_IsOK(res1)) {
33787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33788 }
33789 arg1 = reinterpret_cast< wxWindow * >(argp1);
33790 {
33791 PyThreadState* __tstate = wxPyBeginAllowThreads();
33792 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33793 wxPyEndAllowThreads(__tstate);
33794 if (PyErr_Occurred()) SWIG_fail;
33795 }
33796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33797 return resultobj;
33798 fail:
33799 return NULL;
33800 }
33801
33802
33803 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33804 PyObject *resultobj = 0;
33805 wxWindow *arg1 = (wxWindow *) 0 ;
33806 int arg2 ;
33807 int arg3 ;
33808 int arg4 ;
33809 bool result;
33810 void *argp1 = 0 ;
33811 int res1 = 0 ;
33812 int val2 ;
33813 int ecode2 = 0 ;
33814 int val3 ;
33815 int ecode3 = 0 ;
33816 int val4 ;
33817 int ecode4 = 0 ;
33818 PyObject * obj0 = 0 ;
33819 PyObject * obj1 = 0 ;
33820 PyObject * obj2 = 0 ;
33821 PyObject * obj3 = 0 ;
33822 char * kwnames[] = {
33823 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33824 };
33825
33826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33828 if (!SWIG_IsOK(res1)) {
33829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33830 }
33831 arg1 = reinterpret_cast< wxWindow * >(argp1);
33832 ecode2 = SWIG_AsVal_int(obj1, &val2);
33833 if (!SWIG_IsOK(ecode2)) {
33834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33835 }
33836 arg2 = static_cast< int >(val2);
33837 ecode3 = SWIG_AsVal_int(obj2, &val3);
33838 if (!SWIG_IsOK(ecode3)) {
33839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33840 }
33841 arg3 = static_cast< int >(val3);
33842 ecode4 = SWIG_AsVal_int(obj3, &val4);
33843 if (!SWIG_IsOK(ecode4)) {
33844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33845 }
33846 arg4 = static_cast< int >(val4);
33847 {
33848 PyThreadState* __tstate = wxPyBeginAllowThreads();
33849 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33850 wxPyEndAllowThreads(__tstate);
33851 if (PyErr_Occurred()) SWIG_fail;
33852 }
33853 {
33854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33855 }
33856 return resultobj;
33857 fail:
33858 return NULL;
33859 }
33860
33861
33862 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33863 PyObject *resultobj = 0;
33864 wxWindow *arg1 = (wxWindow *) 0 ;
33865 int arg2 ;
33866 bool result;
33867 void *argp1 = 0 ;
33868 int res1 = 0 ;
33869 int val2 ;
33870 int ecode2 = 0 ;
33871 PyObject * obj0 = 0 ;
33872 PyObject * obj1 = 0 ;
33873 char * kwnames[] = {
33874 (char *) "self",(char *) "hotkeyId", NULL
33875 };
33876
33877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33879 if (!SWIG_IsOK(res1)) {
33880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33881 }
33882 arg1 = reinterpret_cast< wxWindow * >(argp1);
33883 ecode2 = SWIG_AsVal_int(obj1, &val2);
33884 if (!SWIG_IsOK(ecode2)) {
33885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33886 }
33887 arg2 = static_cast< int >(val2);
33888 {
33889 PyThreadState* __tstate = wxPyBeginAllowThreads();
33890 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33891 wxPyEndAllowThreads(__tstate);
33892 if (PyErr_Occurred()) SWIG_fail;
33893 }
33894 {
33895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33896 }
33897 return resultobj;
33898 fail:
33899 return NULL;
33900 }
33901
33902
33903 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33904 PyObject *resultobj = 0;
33905 wxWindow *arg1 = (wxWindow *) 0 ;
33906 wxPoint *arg2 = 0 ;
33907 wxPoint result;
33908 void *argp1 = 0 ;
33909 int res1 = 0 ;
33910 wxPoint temp2 ;
33911 PyObject * obj0 = 0 ;
33912 PyObject * obj1 = 0 ;
33913 char * kwnames[] = {
33914 (char *) "self",(char *) "pt", NULL
33915 };
33916
33917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33919 if (!SWIG_IsOK(res1)) {
33920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33921 }
33922 arg1 = reinterpret_cast< wxWindow * >(argp1);
33923 {
33924 arg2 = &temp2;
33925 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33926 }
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33934 return resultobj;
33935 fail:
33936 return NULL;
33937 }
33938
33939
33940 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33941 PyObject *resultobj = 0;
33942 wxWindow *arg1 = (wxWindow *) 0 ;
33943 wxSize *arg2 = 0 ;
33944 wxSize result;
33945 void *argp1 = 0 ;
33946 int res1 = 0 ;
33947 wxSize temp2 ;
33948 PyObject * obj0 = 0 ;
33949 PyObject * obj1 = 0 ;
33950 char * kwnames[] = {
33951 (char *) "self",(char *) "sz", NULL
33952 };
33953
33954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33956 if (!SWIG_IsOK(res1)) {
33957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33958 }
33959 arg1 = reinterpret_cast< wxWindow * >(argp1);
33960 {
33961 arg2 = &temp2;
33962 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33963 }
33964 {
33965 PyThreadState* __tstate = wxPyBeginAllowThreads();
33966 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33967 wxPyEndAllowThreads(__tstate);
33968 if (PyErr_Occurred()) SWIG_fail;
33969 }
33970 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33971 return resultobj;
33972 fail:
33973 return NULL;
33974 }
33975
33976
33977 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33978 PyObject *resultobj = 0;
33979 wxWindow *arg1 = (wxWindow *) 0 ;
33980 wxPoint *arg2 = 0 ;
33981 wxPoint result;
33982 void *argp1 = 0 ;
33983 int res1 = 0 ;
33984 wxPoint temp2 ;
33985 PyObject * obj0 = 0 ;
33986 PyObject * obj1 = 0 ;
33987 char * kwnames[] = {
33988 (char *) "self",(char *) "pt", NULL
33989 };
33990
33991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33993 if (!SWIG_IsOK(res1)) {
33994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33995 }
33996 arg1 = reinterpret_cast< wxWindow * >(argp1);
33997 {
33998 arg2 = &temp2;
33999 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34000 }
34001 {
34002 PyThreadState* __tstate = wxPyBeginAllowThreads();
34003 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34004 wxPyEndAllowThreads(__tstate);
34005 if (PyErr_Occurred()) SWIG_fail;
34006 }
34007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34008 return resultobj;
34009 fail:
34010 return NULL;
34011 }
34012
34013
34014 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34015 PyObject *resultobj = 0;
34016 wxWindow *arg1 = (wxWindow *) 0 ;
34017 wxSize *arg2 = 0 ;
34018 wxSize result;
34019 void *argp1 = 0 ;
34020 int res1 = 0 ;
34021 wxSize temp2 ;
34022 PyObject * obj0 = 0 ;
34023 PyObject * obj1 = 0 ;
34024 char * kwnames[] = {
34025 (char *) "self",(char *) "sz", NULL
34026 };
34027
34028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34030 if (!SWIG_IsOK(res1)) {
34031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34032 }
34033 arg1 = reinterpret_cast< wxWindow * >(argp1);
34034 {
34035 arg2 = &temp2;
34036 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34037 }
34038 {
34039 PyThreadState* __tstate = wxPyBeginAllowThreads();
34040 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34041 wxPyEndAllowThreads(__tstate);
34042 if (PyErr_Occurred()) SWIG_fail;
34043 }
34044 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34045 return resultobj;
34046 fail:
34047 return NULL;
34048 }
34049
34050
34051 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34052 PyObject *resultobj = 0;
34053 wxWindow *arg1 = (wxWindow *) 0 ;
34054 wxPoint *arg2 = 0 ;
34055 wxPoint result;
34056 void *argp1 = 0 ;
34057 int res1 = 0 ;
34058 wxPoint temp2 ;
34059 PyObject * obj0 = 0 ;
34060 PyObject * obj1 = 0 ;
34061 char * kwnames[] = {
34062 (char *) "self",(char *) "pt", NULL
34063 };
34064
34065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34067 if (!SWIG_IsOK(res1)) {
34068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34069 }
34070 arg1 = reinterpret_cast< wxWindow * >(argp1);
34071 {
34072 arg2 = &temp2;
34073 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34074 }
34075 {
34076 PyThreadState* __tstate = wxPyBeginAllowThreads();
34077 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34078 wxPyEndAllowThreads(__tstate);
34079 if (PyErr_Occurred()) SWIG_fail;
34080 }
34081 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34082 return resultobj;
34083 fail:
34084 return NULL;
34085 }
34086
34087
34088 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34089 PyObject *resultobj = 0;
34090 wxWindow *arg1 = (wxWindow *) 0 ;
34091 wxSize *arg2 = 0 ;
34092 wxSize result;
34093 void *argp1 = 0 ;
34094 int res1 = 0 ;
34095 wxSize temp2 ;
34096 PyObject * obj0 = 0 ;
34097 PyObject * obj1 = 0 ;
34098 char * kwnames[] = {
34099 (char *) "self",(char *) "sz", NULL
34100 };
34101
34102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34104 if (!SWIG_IsOK(res1)) {
34105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34106 }
34107 arg1 = reinterpret_cast< wxWindow * >(argp1);
34108 {
34109 arg2 = &temp2;
34110 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34111 }
34112 {
34113 PyThreadState* __tstate = wxPyBeginAllowThreads();
34114 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34115 wxPyEndAllowThreads(__tstate);
34116 if (PyErr_Occurred()) SWIG_fail;
34117 }
34118 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34119 return resultobj;
34120 fail:
34121 return NULL;
34122 }
34123
34124
34125 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34126 PyObject *resultobj = 0;
34127 wxWindow *arg1 = (wxWindow *) 0 ;
34128 int arg2 ;
34129 int arg3 ;
34130 void *argp1 = 0 ;
34131 int res1 = 0 ;
34132 int val2 ;
34133 int ecode2 = 0 ;
34134 int val3 ;
34135 int ecode3 = 0 ;
34136 PyObject * obj0 = 0 ;
34137 PyObject * obj1 = 0 ;
34138 PyObject * obj2 = 0 ;
34139 char * kwnames[] = {
34140 (char *) "self",(char *) "x",(char *) "y", NULL
34141 };
34142
34143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34145 if (!SWIG_IsOK(res1)) {
34146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34147 }
34148 arg1 = reinterpret_cast< wxWindow * >(argp1);
34149 ecode2 = SWIG_AsVal_int(obj1, &val2);
34150 if (!SWIG_IsOK(ecode2)) {
34151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34152 }
34153 arg2 = static_cast< int >(val2);
34154 ecode3 = SWIG_AsVal_int(obj2, &val3);
34155 if (!SWIG_IsOK(ecode3)) {
34156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34157 }
34158 arg3 = static_cast< int >(val3);
34159 {
34160 PyThreadState* __tstate = wxPyBeginAllowThreads();
34161 (arg1)->WarpPointer(arg2,arg3);
34162 wxPyEndAllowThreads(__tstate);
34163 if (PyErr_Occurred()) SWIG_fail;
34164 }
34165 resultobj = SWIG_Py_Void();
34166 return resultobj;
34167 fail:
34168 return NULL;
34169 }
34170
34171
34172 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34173 PyObject *resultobj = 0;
34174 wxWindow *arg1 = (wxWindow *) 0 ;
34175 void *argp1 = 0 ;
34176 int res1 = 0 ;
34177 PyObject *swig_obj[1] ;
34178
34179 if (!args) SWIG_fail;
34180 swig_obj[0] = args;
34181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34182 if (!SWIG_IsOK(res1)) {
34183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34184 }
34185 arg1 = reinterpret_cast< wxWindow * >(argp1);
34186 {
34187 PyThreadState* __tstate = wxPyBeginAllowThreads();
34188 (arg1)->CaptureMouse();
34189 wxPyEndAllowThreads(__tstate);
34190 if (PyErr_Occurred()) SWIG_fail;
34191 }
34192 resultobj = SWIG_Py_Void();
34193 return resultobj;
34194 fail:
34195 return NULL;
34196 }
34197
34198
34199 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34200 PyObject *resultobj = 0;
34201 wxWindow *arg1 = (wxWindow *) 0 ;
34202 void *argp1 = 0 ;
34203 int res1 = 0 ;
34204 PyObject *swig_obj[1] ;
34205
34206 if (!args) SWIG_fail;
34207 swig_obj[0] = args;
34208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34209 if (!SWIG_IsOK(res1)) {
34210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34211 }
34212 arg1 = reinterpret_cast< wxWindow * >(argp1);
34213 {
34214 PyThreadState* __tstate = wxPyBeginAllowThreads();
34215 (arg1)->ReleaseMouse();
34216 wxPyEndAllowThreads(__tstate);
34217 if (PyErr_Occurred()) SWIG_fail;
34218 }
34219 resultobj = SWIG_Py_Void();
34220 return resultobj;
34221 fail:
34222 return NULL;
34223 }
34224
34225
34226 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34227 PyObject *resultobj = 0;
34228 wxWindow *result = 0 ;
34229
34230 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34231 {
34232 if (!wxPyCheckForApp()) SWIG_fail;
34233 PyThreadState* __tstate = wxPyBeginAllowThreads();
34234 result = (wxWindow *)wxWindow::GetCapture();
34235 wxPyEndAllowThreads(__tstate);
34236 if (PyErr_Occurred()) SWIG_fail;
34237 }
34238 {
34239 resultobj = wxPyMake_wxObject(result, 0);
34240 }
34241 return resultobj;
34242 fail:
34243 return NULL;
34244 }
34245
34246
34247 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34248 PyObject *resultobj = 0;
34249 wxWindow *arg1 = (wxWindow *) 0 ;
34250 bool result;
34251 void *argp1 = 0 ;
34252 int res1 = 0 ;
34253 PyObject *swig_obj[1] ;
34254
34255 if (!args) SWIG_fail;
34256 swig_obj[0] = args;
34257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34258 if (!SWIG_IsOK(res1)) {
34259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34260 }
34261 arg1 = reinterpret_cast< wxWindow * >(argp1);
34262 {
34263 PyThreadState* __tstate = wxPyBeginAllowThreads();
34264 result = (bool)((wxWindow const *)arg1)->HasCapture();
34265 wxPyEndAllowThreads(__tstate);
34266 if (PyErr_Occurred()) SWIG_fail;
34267 }
34268 {
34269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34270 }
34271 return resultobj;
34272 fail:
34273 return NULL;
34274 }
34275
34276
34277 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34278 PyObject *resultobj = 0;
34279 wxWindow *arg1 = (wxWindow *) 0 ;
34280 bool arg2 = (bool) true ;
34281 wxRect *arg3 = (wxRect *) NULL ;
34282 void *argp1 = 0 ;
34283 int res1 = 0 ;
34284 bool val2 ;
34285 int ecode2 = 0 ;
34286 void *argp3 = 0 ;
34287 int res3 = 0 ;
34288 PyObject * obj0 = 0 ;
34289 PyObject * obj1 = 0 ;
34290 PyObject * obj2 = 0 ;
34291 char * kwnames[] = {
34292 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34293 };
34294
34295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34297 if (!SWIG_IsOK(res1)) {
34298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34299 }
34300 arg1 = reinterpret_cast< wxWindow * >(argp1);
34301 if (obj1) {
34302 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34303 if (!SWIG_IsOK(ecode2)) {
34304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34305 }
34306 arg2 = static_cast< bool >(val2);
34307 }
34308 if (obj2) {
34309 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34310 if (!SWIG_IsOK(res3)) {
34311 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34312 }
34313 arg3 = reinterpret_cast< wxRect * >(argp3);
34314 }
34315 {
34316 PyThreadState* __tstate = wxPyBeginAllowThreads();
34317 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34318 wxPyEndAllowThreads(__tstate);
34319 if (PyErr_Occurred()) SWIG_fail;
34320 }
34321 resultobj = SWIG_Py_Void();
34322 return resultobj;
34323 fail:
34324 return NULL;
34325 }
34326
34327
34328 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34329 PyObject *resultobj = 0;
34330 wxWindow *arg1 = (wxWindow *) 0 ;
34331 wxRect *arg2 = 0 ;
34332 bool arg3 = (bool) true ;
34333 void *argp1 = 0 ;
34334 int res1 = 0 ;
34335 wxRect temp2 ;
34336 bool val3 ;
34337 int ecode3 = 0 ;
34338 PyObject * obj0 = 0 ;
34339 PyObject * obj1 = 0 ;
34340 PyObject * obj2 = 0 ;
34341 char * kwnames[] = {
34342 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34343 };
34344
34345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34347 if (!SWIG_IsOK(res1)) {
34348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34349 }
34350 arg1 = reinterpret_cast< wxWindow * >(argp1);
34351 {
34352 arg2 = &temp2;
34353 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34354 }
34355 if (obj2) {
34356 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34357 if (!SWIG_IsOK(ecode3)) {
34358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34359 }
34360 arg3 = static_cast< bool >(val3);
34361 }
34362 {
34363 PyThreadState* __tstate = wxPyBeginAllowThreads();
34364 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34365 wxPyEndAllowThreads(__tstate);
34366 if (PyErr_Occurred()) SWIG_fail;
34367 }
34368 resultobj = SWIG_Py_Void();
34369 return resultobj;
34370 fail:
34371 return NULL;
34372 }
34373
34374
34375 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34376 PyObject *resultobj = 0;
34377 wxWindow *arg1 = (wxWindow *) 0 ;
34378 void *argp1 = 0 ;
34379 int res1 = 0 ;
34380 PyObject *swig_obj[1] ;
34381
34382 if (!args) SWIG_fail;
34383 swig_obj[0] = args;
34384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34385 if (!SWIG_IsOK(res1)) {
34386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34387 }
34388 arg1 = reinterpret_cast< wxWindow * >(argp1);
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 (arg1)->Update();
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 resultobj = SWIG_Py_Void();
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 void *argp1 = 0 ;
34406 int res1 = 0 ;
34407 PyObject *swig_obj[1] ;
34408
34409 if (!args) SWIG_fail;
34410 swig_obj[0] = args;
34411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34412 if (!SWIG_IsOK(res1)) {
34413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34414 }
34415 arg1 = reinterpret_cast< wxWindow * >(argp1);
34416 {
34417 PyThreadState* __tstate = wxPyBeginAllowThreads();
34418 (arg1)->ClearBackground();
34419 wxPyEndAllowThreads(__tstate);
34420 if (PyErr_Occurred()) SWIG_fail;
34421 }
34422 resultobj = SWIG_Py_Void();
34423 return resultobj;
34424 fail:
34425 return NULL;
34426 }
34427
34428
34429 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34430 PyObject *resultobj = 0;
34431 wxWindow *arg1 = (wxWindow *) 0 ;
34432 void *argp1 = 0 ;
34433 int res1 = 0 ;
34434 PyObject *swig_obj[1] ;
34435
34436 if (!args) SWIG_fail;
34437 swig_obj[0] = args;
34438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34439 if (!SWIG_IsOK(res1)) {
34440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34441 }
34442 arg1 = reinterpret_cast< wxWindow * >(argp1);
34443 {
34444 PyThreadState* __tstate = wxPyBeginAllowThreads();
34445 (arg1)->Freeze();
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 resultobj = SWIG_Py_Void();
34450 return resultobj;
34451 fail:
34452 return NULL;
34453 }
34454
34455
34456 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34457 PyObject *resultobj = 0;
34458 wxWindow *arg1 = (wxWindow *) 0 ;
34459 void *argp1 = 0 ;
34460 int res1 = 0 ;
34461 PyObject *swig_obj[1] ;
34462
34463 if (!args) SWIG_fail;
34464 swig_obj[0] = args;
34465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34466 if (!SWIG_IsOK(res1)) {
34467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34468 }
34469 arg1 = reinterpret_cast< wxWindow * >(argp1);
34470 {
34471 PyThreadState* __tstate = wxPyBeginAllowThreads();
34472 (arg1)->Thaw();
34473 wxPyEndAllowThreads(__tstate);
34474 if (PyErr_Occurred()) SWIG_fail;
34475 }
34476 resultobj = SWIG_Py_Void();
34477 return resultobj;
34478 fail:
34479 return NULL;
34480 }
34481
34482
34483 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34484 PyObject *resultobj = 0;
34485 wxWindow *arg1 = (wxWindow *) 0 ;
34486 wxDC *arg2 = 0 ;
34487 void *argp1 = 0 ;
34488 int res1 = 0 ;
34489 void *argp2 = 0 ;
34490 int res2 = 0 ;
34491 PyObject * obj0 = 0 ;
34492 PyObject * obj1 = 0 ;
34493 char * kwnames[] = {
34494 (char *) "self",(char *) "dc", NULL
34495 };
34496
34497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34499 if (!SWIG_IsOK(res1)) {
34500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34501 }
34502 arg1 = reinterpret_cast< wxWindow * >(argp1);
34503 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34504 if (!SWIG_IsOK(res2)) {
34505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34506 }
34507 if (!argp2) {
34508 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34509 }
34510 arg2 = reinterpret_cast< wxDC * >(argp2);
34511 {
34512 PyThreadState* __tstate = wxPyBeginAllowThreads();
34513 (arg1)->PrepareDC(*arg2);
34514 wxPyEndAllowThreads(__tstate);
34515 if (PyErr_Occurred()) SWIG_fail;
34516 }
34517 resultobj = SWIG_Py_Void();
34518 return resultobj;
34519 fail:
34520 return NULL;
34521 }
34522
34523
34524 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34525 PyObject *resultobj = 0;
34526 wxWindow *arg1 = (wxWindow *) 0 ;
34527 wxRegion *result = 0 ;
34528 void *argp1 = 0 ;
34529 int res1 = 0 ;
34530 PyObject *swig_obj[1] ;
34531
34532 if (!args) SWIG_fail;
34533 swig_obj[0] = args;
34534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34535 if (!SWIG_IsOK(res1)) {
34536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34537 }
34538 arg1 = reinterpret_cast< wxWindow * >(argp1);
34539 {
34540 PyThreadState* __tstate = wxPyBeginAllowThreads();
34541 {
34542 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34543 result = (wxRegion *) &_result_ref;
34544 }
34545 wxPyEndAllowThreads(__tstate);
34546 if (PyErr_Occurred()) SWIG_fail;
34547 }
34548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34549 return resultobj;
34550 fail:
34551 return NULL;
34552 }
34553
34554
34555 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34556 PyObject *resultobj = 0;
34557 wxWindow *arg1 = (wxWindow *) 0 ;
34558 wxRect result;
34559 void *argp1 = 0 ;
34560 int res1 = 0 ;
34561 PyObject *swig_obj[1] ;
34562
34563 if (!args) SWIG_fail;
34564 swig_obj[0] = args;
34565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34566 if (!SWIG_IsOK(res1)) {
34567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34568 }
34569 arg1 = reinterpret_cast< wxWindow * >(argp1);
34570 {
34571 PyThreadState* __tstate = wxPyBeginAllowThreads();
34572 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34573 wxPyEndAllowThreads(__tstate);
34574 if (PyErr_Occurred()) SWIG_fail;
34575 }
34576 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34577 return resultobj;
34578 fail:
34579 return NULL;
34580 }
34581
34582
34583 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34584 PyObject *resultobj = 0;
34585 wxWindow *arg1 = (wxWindow *) 0 ;
34586 int arg2 ;
34587 int arg3 ;
34588 int arg4 = (int) 1 ;
34589 int arg5 = (int) 1 ;
34590 bool result;
34591 void *argp1 = 0 ;
34592 int res1 = 0 ;
34593 int val2 ;
34594 int ecode2 = 0 ;
34595 int val3 ;
34596 int ecode3 = 0 ;
34597 int val4 ;
34598 int ecode4 = 0 ;
34599 int val5 ;
34600 int ecode5 = 0 ;
34601 PyObject * obj0 = 0 ;
34602 PyObject * obj1 = 0 ;
34603 PyObject * obj2 = 0 ;
34604 PyObject * obj3 = 0 ;
34605 PyObject * obj4 = 0 ;
34606 char * kwnames[] = {
34607 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34608 };
34609
34610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34612 if (!SWIG_IsOK(res1)) {
34613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34614 }
34615 arg1 = reinterpret_cast< wxWindow * >(argp1);
34616 ecode2 = SWIG_AsVal_int(obj1, &val2);
34617 if (!SWIG_IsOK(ecode2)) {
34618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34619 }
34620 arg2 = static_cast< int >(val2);
34621 ecode3 = SWIG_AsVal_int(obj2, &val3);
34622 if (!SWIG_IsOK(ecode3)) {
34623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34624 }
34625 arg3 = static_cast< int >(val3);
34626 if (obj3) {
34627 ecode4 = SWIG_AsVal_int(obj3, &val4);
34628 if (!SWIG_IsOK(ecode4)) {
34629 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34630 }
34631 arg4 = static_cast< int >(val4);
34632 }
34633 if (obj4) {
34634 ecode5 = SWIG_AsVal_int(obj4, &val5);
34635 if (!SWIG_IsOK(ecode5)) {
34636 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34637 }
34638 arg5 = static_cast< int >(val5);
34639 }
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 {
34647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34648 }
34649 return resultobj;
34650 fail:
34651 return NULL;
34652 }
34653
34654
34655 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34656 PyObject *resultobj = 0;
34657 wxWindow *arg1 = (wxWindow *) 0 ;
34658 wxPoint *arg2 = 0 ;
34659 bool result;
34660 void *argp1 = 0 ;
34661 int res1 = 0 ;
34662 wxPoint temp2 ;
34663 PyObject * obj0 = 0 ;
34664 PyObject * obj1 = 0 ;
34665 char * kwnames[] = {
34666 (char *) "self",(char *) "pt", NULL
34667 };
34668
34669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34671 if (!SWIG_IsOK(res1)) {
34672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34673 }
34674 arg1 = reinterpret_cast< wxWindow * >(argp1);
34675 {
34676 arg2 = &temp2;
34677 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34678 }
34679 {
34680 PyThreadState* __tstate = wxPyBeginAllowThreads();
34681 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34682 wxPyEndAllowThreads(__tstate);
34683 if (PyErr_Occurred()) SWIG_fail;
34684 }
34685 {
34686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34687 }
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj = 0;
34696 wxWindow *arg1 = (wxWindow *) 0 ;
34697 wxRect *arg2 = 0 ;
34698 bool result;
34699 void *argp1 = 0 ;
34700 int res1 = 0 ;
34701 wxRect temp2 ;
34702 PyObject * obj0 = 0 ;
34703 PyObject * obj1 = 0 ;
34704 char * kwnames[] = {
34705 (char *) "self",(char *) "rect", NULL
34706 };
34707
34708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34710 if (!SWIG_IsOK(res1)) {
34711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34712 }
34713 arg1 = reinterpret_cast< wxWindow * >(argp1);
34714 {
34715 arg2 = &temp2;
34716 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34717 }
34718 {
34719 PyThreadState* __tstate = wxPyBeginAllowThreads();
34720 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34721 wxPyEndAllowThreads(__tstate);
34722 if (PyErr_Occurred()) SWIG_fail;
34723 }
34724 {
34725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34726 }
34727 return resultobj;
34728 fail:
34729 return NULL;
34730 }
34731
34732
34733 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34734 PyObject *resultobj = 0;
34735 wxWindow *arg1 = (wxWindow *) 0 ;
34736 SwigValueWrapper<wxVisualAttributes > result;
34737 void *argp1 = 0 ;
34738 int res1 = 0 ;
34739 PyObject *swig_obj[1] ;
34740
34741 if (!args) SWIG_fail;
34742 swig_obj[0] = args;
34743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34744 if (!SWIG_IsOK(res1)) {
34745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34746 }
34747 arg1 = reinterpret_cast< wxWindow * >(argp1);
34748 {
34749 PyThreadState* __tstate = wxPyBeginAllowThreads();
34750 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34751 wxPyEndAllowThreads(__tstate);
34752 if (PyErr_Occurred()) SWIG_fail;
34753 }
34754 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34755 return resultobj;
34756 fail:
34757 return NULL;
34758 }
34759
34760
34761 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34762 PyObject *resultobj = 0;
34763 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34764 SwigValueWrapper<wxVisualAttributes > result;
34765 int val1 ;
34766 int ecode1 = 0 ;
34767 PyObject * obj0 = 0 ;
34768 char * kwnames[] = {
34769 (char *) "variant", NULL
34770 };
34771
34772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34773 if (obj0) {
34774 ecode1 = SWIG_AsVal_int(obj0, &val1);
34775 if (!SWIG_IsOK(ecode1)) {
34776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34777 }
34778 arg1 = static_cast< wxWindowVariant >(val1);
34779 }
34780 {
34781 if (!wxPyCheckForApp()) SWIG_fail;
34782 PyThreadState* __tstate = wxPyBeginAllowThreads();
34783 result = wxWindow::GetClassDefaultAttributes(arg1);
34784 wxPyEndAllowThreads(__tstate);
34785 if (PyErr_Occurred()) SWIG_fail;
34786 }
34787 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34788 return resultobj;
34789 fail:
34790 return NULL;
34791 }
34792
34793
34794 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34795 PyObject *resultobj = 0;
34796 wxWindow *arg1 = (wxWindow *) 0 ;
34797 wxColour *arg2 = 0 ;
34798 bool result;
34799 void *argp1 = 0 ;
34800 int res1 = 0 ;
34801 wxColour temp2 ;
34802 PyObject * obj0 = 0 ;
34803 PyObject * obj1 = 0 ;
34804 char * kwnames[] = {
34805 (char *) "self",(char *) "colour", NULL
34806 };
34807
34808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34810 if (!SWIG_IsOK(res1)) {
34811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34812 }
34813 arg1 = reinterpret_cast< wxWindow * >(argp1);
34814 {
34815 arg2 = &temp2;
34816 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34817 }
34818 {
34819 PyThreadState* __tstate = wxPyBeginAllowThreads();
34820 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34821 wxPyEndAllowThreads(__tstate);
34822 if (PyErr_Occurred()) SWIG_fail;
34823 }
34824 {
34825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34826 }
34827 return resultobj;
34828 fail:
34829 return NULL;
34830 }
34831
34832
34833 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34834 PyObject *resultobj = 0;
34835 wxWindow *arg1 = (wxWindow *) 0 ;
34836 wxColour *arg2 = 0 ;
34837 void *argp1 = 0 ;
34838 int res1 = 0 ;
34839 wxColour temp2 ;
34840 PyObject * obj0 = 0 ;
34841 PyObject * obj1 = 0 ;
34842 char * kwnames[] = {
34843 (char *) "self",(char *) "colour", NULL
34844 };
34845
34846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34848 if (!SWIG_IsOK(res1)) {
34849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34850 }
34851 arg1 = reinterpret_cast< wxWindow * >(argp1);
34852 {
34853 arg2 = &temp2;
34854 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34855 }
34856 {
34857 PyThreadState* __tstate = wxPyBeginAllowThreads();
34858 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34859 wxPyEndAllowThreads(__tstate);
34860 if (PyErr_Occurred()) SWIG_fail;
34861 }
34862 resultobj = SWIG_Py_Void();
34863 return resultobj;
34864 fail:
34865 return NULL;
34866 }
34867
34868
34869 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34870 PyObject *resultobj = 0;
34871 wxWindow *arg1 = (wxWindow *) 0 ;
34872 wxColour *arg2 = 0 ;
34873 bool result;
34874 void *argp1 = 0 ;
34875 int res1 = 0 ;
34876 wxColour temp2 ;
34877 PyObject * obj0 = 0 ;
34878 PyObject * obj1 = 0 ;
34879 char * kwnames[] = {
34880 (char *) "self",(char *) "colour", NULL
34881 };
34882
34883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34885 if (!SWIG_IsOK(res1)) {
34886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34887 }
34888 arg1 = reinterpret_cast< wxWindow * >(argp1);
34889 {
34890 arg2 = &temp2;
34891 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34892 }
34893 {
34894 PyThreadState* __tstate = wxPyBeginAllowThreads();
34895 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 {
34900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34901 }
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34909 PyObject *resultobj = 0;
34910 wxWindow *arg1 = (wxWindow *) 0 ;
34911 wxColour *arg2 = 0 ;
34912 void *argp1 = 0 ;
34913 int res1 = 0 ;
34914 wxColour temp2 ;
34915 PyObject * obj0 = 0 ;
34916 PyObject * obj1 = 0 ;
34917 char * kwnames[] = {
34918 (char *) "self",(char *) "colour", NULL
34919 };
34920
34921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34923 if (!SWIG_IsOK(res1)) {
34924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34925 }
34926 arg1 = reinterpret_cast< wxWindow * >(argp1);
34927 {
34928 arg2 = &temp2;
34929 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34930 }
34931 {
34932 PyThreadState* __tstate = wxPyBeginAllowThreads();
34933 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34934 wxPyEndAllowThreads(__tstate);
34935 if (PyErr_Occurred()) SWIG_fail;
34936 }
34937 resultobj = SWIG_Py_Void();
34938 return resultobj;
34939 fail:
34940 return NULL;
34941 }
34942
34943
34944 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34945 PyObject *resultobj = 0;
34946 wxWindow *arg1 = (wxWindow *) 0 ;
34947 wxColour result;
34948 void *argp1 = 0 ;
34949 int res1 = 0 ;
34950 PyObject *swig_obj[1] ;
34951
34952 if (!args) SWIG_fail;
34953 swig_obj[0] = args;
34954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34955 if (!SWIG_IsOK(res1)) {
34956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34957 }
34958 arg1 = reinterpret_cast< wxWindow * >(argp1);
34959 {
34960 PyThreadState* __tstate = wxPyBeginAllowThreads();
34961 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34962 wxPyEndAllowThreads(__tstate);
34963 if (PyErr_Occurred()) SWIG_fail;
34964 }
34965 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34966 return resultobj;
34967 fail:
34968 return NULL;
34969 }
34970
34971
34972 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34973 PyObject *resultobj = 0;
34974 wxWindow *arg1 = (wxWindow *) 0 ;
34975 wxColour result;
34976 void *argp1 = 0 ;
34977 int res1 = 0 ;
34978 PyObject *swig_obj[1] ;
34979
34980 if (!args) SWIG_fail;
34981 swig_obj[0] = args;
34982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34983 if (!SWIG_IsOK(res1)) {
34984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34985 }
34986 arg1 = reinterpret_cast< wxWindow * >(argp1);
34987 {
34988 PyThreadState* __tstate = wxPyBeginAllowThreads();
34989 result = ((wxWindow const *)arg1)->GetForegroundColour();
34990 wxPyEndAllowThreads(__tstate);
34991 if (PyErr_Occurred()) SWIG_fail;
34992 }
34993 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34994 return resultobj;
34995 fail:
34996 return NULL;
34997 }
34998
34999
35000 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35001 PyObject *resultobj = 0;
35002 wxWindow *arg1 = (wxWindow *) 0 ;
35003 bool result;
35004 void *argp1 = 0 ;
35005 int res1 = 0 ;
35006 PyObject *swig_obj[1] ;
35007
35008 if (!args) SWIG_fail;
35009 swig_obj[0] = args;
35010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35011 if (!SWIG_IsOK(res1)) {
35012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35013 }
35014 arg1 = reinterpret_cast< wxWindow * >(argp1);
35015 {
35016 PyThreadState* __tstate = wxPyBeginAllowThreads();
35017 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35018 wxPyEndAllowThreads(__tstate);
35019 if (PyErr_Occurred()) SWIG_fail;
35020 }
35021 {
35022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35023 }
35024 return resultobj;
35025 fail:
35026 return NULL;
35027 }
35028
35029
35030 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35031 PyObject *resultobj = 0;
35032 wxWindow *arg1 = (wxWindow *) 0 ;
35033 bool result;
35034 void *argp1 = 0 ;
35035 int res1 = 0 ;
35036 PyObject *swig_obj[1] ;
35037
35038 if (!args) SWIG_fail;
35039 swig_obj[0] = args;
35040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35041 if (!SWIG_IsOK(res1)) {
35042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35043 }
35044 arg1 = reinterpret_cast< wxWindow * >(argp1);
35045 {
35046 PyThreadState* __tstate = wxPyBeginAllowThreads();
35047 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35048 wxPyEndAllowThreads(__tstate);
35049 if (PyErr_Occurred()) SWIG_fail;
35050 }
35051 {
35052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35053 }
35054 return resultobj;
35055 fail:
35056 return NULL;
35057 }
35058
35059
35060 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35061 PyObject *resultobj = 0;
35062 wxWindow *arg1 = (wxWindow *) 0 ;
35063 wxBackgroundStyle arg2 ;
35064 bool result;
35065 void *argp1 = 0 ;
35066 int res1 = 0 ;
35067 int val2 ;
35068 int ecode2 = 0 ;
35069 PyObject * obj0 = 0 ;
35070 PyObject * obj1 = 0 ;
35071 char * kwnames[] = {
35072 (char *) "self",(char *) "style", NULL
35073 };
35074
35075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35077 if (!SWIG_IsOK(res1)) {
35078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35079 }
35080 arg1 = reinterpret_cast< wxWindow * >(argp1);
35081 ecode2 = SWIG_AsVal_int(obj1, &val2);
35082 if (!SWIG_IsOK(ecode2)) {
35083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35084 }
35085 arg2 = static_cast< wxBackgroundStyle >(val2);
35086 {
35087 PyThreadState* __tstate = wxPyBeginAllowThreads();
35088 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35089 wxPyEndAllowThreads(__tstate);
35090 if (PyErr_Occurred()) SWIG_fail;
35091 }
35092 {
35093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35094 }
35095 return resultobj;
35096 fail:
35097 return NULL;
35098 }
35099
35100
35101 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35102 PyObject *resultobj = 0;
35103 wxWindow *arg1 = (wxWindow *) 0 ;
35104 wxBackgroundStyle result;
35105 void *argp1 = 0 ;
35106 int res1 = 0 ;
35107 PyObject *swig_obj[1] ;
35108
35109 if (!args) SWIG_fail;
35110 swig_obj[0] = args;
35111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35112 if (!SWIG_IsOK(res1)) {
35113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35114 }
35115 arg1 = reinterpret_cast< wxWindow * >(argp1);
35116 {
35117 PyThreadState* __tstate = wxPyBeginAllowThreads();
35118 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35119 wxPyEndAllowThreads(__tstate);
35120 if (PyErr_Occurred()) SWIG_fail;
35121 }
35122 resultobj = SWIG_From_int(static_cast< int >(result));
35123 return resultobj;
35124 fail:
35125 return NULL;
35126 }
35127
35128
35129 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35130 PyObject *resultobj = 0;
35131 wxWindow *arg1 = (wxWindow *) 0 ;
35132 bool result;
35133 void *argp1 = 0 ;
35134 int res1 = 0 ;
35135 PyObject *swig_obj[1] ;
35136
35137 if (!args) SWIG_fail;
35138 swig_obj[0] = args;
35139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35140 if (!SWIG_IsOK(res1)) {
35141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35142 }
35143 arg1 = reinterpret_cast< wxWindow * >(argp1);
35144 {
35145 PyThreadState* __tstate = wxPyBeginAllowThreads();
35146 result = (bool)(arg1)->HasTransparentBackground();
35147 wxPyEndAllowThreads(__tstate);
35148 if (PyErr_Occurred()) SWIG_fail;
35149 }
35150 {
35151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35152 }
35153 return resultobj;
35154 fail:
35155 return NULL;
35156 }
35157
35158
35159 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35160 PyObject *resultobj = 0;
35161 wxWindow *arg1 = (wxWindow *) 0 ;
35162 wxCursor *arg2 = 0 ;
35163 bool result;
35164 void *argp1 = 0 ;
35165 int res1 = 0 ;
35166 void *argp2 = 0 ;
35167 int res2 = 0 ;
35168 PyObject * obj0 = 0 ;
35169 PyObject * obj1 = 0 ;
35170 char * kwnames[] = {
35171 (char *) "self",(char *) "cursor", NULL
35172 };
35173
35174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35176 if (!SWIG_IsOK(res1)) {
35177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35178 }
35179 arg1 = reinterpret_cast< wxWindow * >(argp1);
35180 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35181 if (!SWIG_IsOK(res2)) {
35182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35183 }
35184 if (!argp2) {
35185 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35186 }
35187 arg2 = reinterpret_cast< wxCursor * >(argp2);
35188 {
35189 PyThreadState* __tstate = wxPyBeginAllowThreads();
35190 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35191 wxPyEndAllowThreads(__tstate);
35192 if (PyErr_Occurred()) SWIG_fail;
35193 }
35194 {
35195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35196 }
35197 return resultobj;
35198 fail:
35199 return NULL;
35200 }
35201
35202
35203 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35204 PyObject *resultobj = 0;
35205 wxWindow *arg1 = (wxWindow *) 0 ;
35206 wxCursor result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 PyObject *swig_obj[1] ;
35210
35211 if (!args) SWIG_fail;
35212 swig_obj[0] = args;
35213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35216 }
35217 arg1 = reinterpret_cast< wxWindow * >(argp1);
35218 {
35219 PyThreadState* __tstate = wxPyBeginAllowThreads();
35220 result = (arg1)->GetCursor();
35221 wxPyEndAllowThreads(__tstate);
35222 if (PyErr_Occurred()) SWIG_fail;
35223 }
35224 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35232 PyObject *resultobj = 0;
35233 wxWindow *arg1 = (wxWindow *) 0 ;
35234 wxFont *arg2 = 0 ;
35235 bool result;
35236 void *argp1 = 0 ;
35237 int res1 = 0 ;
35238 void *argp2 = 0 ;
35239 int res2 = 0 ;
35240 PyObject * obj0 = 0 ;
35241 PyObject * obj1 = 0 ;
35242 char * kwnames[] = {
35243 (char *) "self",(char *) "font", NULL
35244 };
35245
35246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35248 if (!SWIG_IsOK(res1)) {
35249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35250 }
35251 arg1 = reinterpret_cast< wxWindow * >(argp1);
35252 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35253 if (!SWIG_IsOK(res2)) {
35254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35255 }
35256 if (!argp2) {
35257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35258 }
35259 arg2 = reinterpret_cast< wxFont * >(argp2);
35260 {
35261 PyThreadState* __tstate = wxPyBeginAllowThreads();
35262 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 {
35267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35268 }
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35276 PyObject *resultobj = 0;
35277 wxWindow *arg1 = (wxWindow *) 0 ;
35278 wxFont *arg2 = 0 ;
35279 void *argp1 = 0 ;
35280 int res1 = 0 ;
35281 void *argp2 = 0 ;
35282 int res2 = 0 ;
35283 PyObject * obj0 = 0 ;
35284 PyObject * obj1 = 0 ;
35285 char * kwnames[] = {
35286 (char *) "self",(char *) "font", NULL
35287 };
35288
35289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35291 if (!SWIG_IsOK(res1)) {
35292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35293 }
35294 arg1 = reinterpret_cast< wxWindow * >(argp1);
35295 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35296 if (!SWIG_IsOK(res2)) {
35297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35298 }
35299 if (!argp2) {
35300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35301 }
35302 arg2 = reinterpret_cast< wxFont * >(argp2);
35303 {
35304 PyThreadState* __tstate = wxPyBeginAllowThreads();
35305 (arg1)->SetOwnFont((wxFont const &)*arg2);
35306 wxPyEndAllowThreads(__tstate);
35307 if (PyErr_Occurred()) SWIG_fail;
35308 }
35309 resultobj = SWIG_Py_Void();
35310 return resultobj;
35311 fail:
35312 return NULL;
35313 }
35314
35315
35316 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35317 PyObject *resultobj = 0;
35318 wxWindow *arg1 = (wxWindow *) 0 ;
35319 wxFont result;
35320 void *argp1 = 0 ;
35321 int res1 = 0 ;
35322 PyObject *swig_obj[1] ;
35323
35324 if (!args) SWIG_fail;
35325 swig_obj[0] = args;
35326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35327 if (!SWIG_IsOK(res1)) {
35328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35329 }
35330 arg1 = reinterpret_cast< wxWindow * >(argp1);
35331 {
35332 PyThreadState* __tstate = wxPyBeginAllowThreads();
35333 result = (arg1)->GetFont();
35334 wxPyEndAllowThreads(__tstate);
35335 if (PyErr_Occurred()) SWIG_fail;
35336 }
35337 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35338 return resultobj;
35339 fail:
35340 return NULL;
35341 }
35342
35343
35344 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35345 PyObject *resultobj = 0;
35346 wxWindow *arg1 = (wxWindow *) 0 ;
35347 wxCaret *arg2 = (wxCaret *) 0 ;
35348 void *argp1 = 0 ;
35349 int res1 = 0 ;
35350 int res2 = 0 ;
35351 PyObject * obj0 = 0 ;
35352 PyObject * obj1 = 0 ;
35353 char * kwnames[] = {
35354 (char *) "self",(char *) "caret", NULL
35355 };
35356
35357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35359 if (!SWIG_IsOK(res1)) {
35360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35361 }
35362 arg1 = reinterpret_cast< wxWindow * >(argp1);
35363 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35364 if (!SWIG_IsOK(res2)) {
35365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35366 }
35367 {
35368 PyThreadState* __tstate = wxPyBeginAllowThreads();
35369 (arg1)->SetCaret(arg2);
35370 wxPyEndAllowThreads(__tstate);
35371 if (PyErr_Occurred()) SWIG_fail;
35372 }
35373 resultobj = SWIG_Py_Void();
35374 return resultobj;
35375 fail:
35376 return NULL;
35377 }
35378
35379
35380 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35381 PyObject *resultobj = 0;
35382 wxWindow *arg1 = (wxWindow *) 0 ;
35383 wxCaret *result = 0 ;
35384 void *argp1 = 0 ;
35385 int res1 = 0 ;
35386 PyObject *swig_obj[1] ;
35387
35388 if (!args) SWIG_fail;
35389 swig_obj[0] = args;
35390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35391 if (!SWIG_IsOK(res1)) {
35392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35393 }
35394 arg1 = reinterpret_cast< wxWindow * >(argp1);
35395 {
35396 PyThreadState* __tstate = wxPyBeginAllowThreads();
35397 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35398 wxPyEndAllowThreads(__tstate);
35399 if (PyErr_Occurred()) SWIG_fail;
35400 }
35401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35402 return resultobj;
35403 fail:
35404 return NULL;
35405 }
35406
35407
35408 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35409 PyObject *resultobj = 0;
35410 wxWindow *arg1 = (wxWindow *) 0 ;
35411 int result;
35412 void *argp1 = 0 ;
35413 int res1 = 0 ;
35414 PyObject *swig_obj[1] ;
35415
35416 if (!args) SWIG_fail;
35417 swig_obj[0] = args;
35418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35419 if (!SWIG_IsOK(res1)) {
35420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35421 }
35422 arg1 = reinterpret_cast< wxWindow * >(argp1);
35423 {
35424 PyThreadState* __tstate = wxPyBeginAllowThreads();
35425 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 resultobj = SWIG_From_int(static_cast< int >(result));
35430 return resultobj;
35431 fail:
35432 return NULL;
35433 }
35434
35435
35436 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35437 PyObject *resultobj = 0;
35438 wxWindow *arg1 = (wxWindow *) 0 ;
35439 int result;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 PyObject *swig_obj[1] ;
35443
35444 if (!args) SWIG_fail;
35445 swig_obj[0] = args;
35446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35449 }
35450 arg1 = reinterpret_cast< wxWindow * >(argp1);
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 resultobj = SWIG_From_int(static_cast< int >(result));
35458 return resultobj;
35459 fail:
35460 return NULL;
35461 }
35462
35463
35464 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35465 PyObject *resultobj = 0;
35466 wxWindow *arg1 = (wxWindow *) 0 ;
35467 wxString *arg2 = 0 ;
35468 int *arg3 = (int *) 0 ;
35469 int *arg4 = (int *) 0 ;
35470 void *argp1 = 0 ;
35471 int res1 = 0 ;
35472 bool temp2 = false ;
35473 int temp3 ;
35474 int res3 = SWIG_TMPOBJ ;
35475 int temp4 ;
35476 int res4 = SWIG_TMPOBJ ;
35477 PyObject * obj0 = 0 ;
35478 PyObject * obj1 = 0 ;
35479 char * kwnames[] = {
35480 (char *) "self",(char *) "string", NULL
35481 };
35482
35483 arg3 = &temp3;
35484 arg4 = &temp4;
35485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35487 if (!SWIG_IsOK(res1)) {
35488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35489 }
35490 arg1 = reinterpret_cast< wxWindow * >(argp1);
35491 {
35492 arg2 = wxString_in_helper(obj1);
35493 if (arg2 == NULL) SWIG_fail;
35494 temp2 = true;
35495 }
35496 {
35497 PyThreadState* __tstate = wxPyBeginAllowThreads();
35498 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35499 wxPyEndAllowThreads(__tstate);
35500 if (PyErr_Occurred()) SWIG_fail;
35501 }
35502 resultobj = SWIG_Py_Void();
35503 if (SWIG_IsTmpObj(res3)) {
35504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35505 } else {
35506 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35507 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35508 }
35509 if (SWIG_IsTmpObj(res4)) {
35510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35511 } else {
35512 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35514 }
35515 {
35516 if (temp2)
35517 delete arg2;
35518 }
35519 return resultobj;
35520 fail:
35521 {
35522 if (temp2)
35523 delete arg2;
35524 }
35525 return NULL;
35526 }
35527
35528
35529 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35530 PyObject *resultobj = 0;
35531 wxWindow *arg1 = (wxWindow *) 0 ;
35532 wxString *arg2 = 0 ;
35533 int *arg3 = (int *) 0 ;
35534 int *arg4 = (int *) 0 ;
35535 int *arg5 = (int *) 0 ;
35536 int *arg6 = (int *) 0 ;
35537 wxFont *arg7 = (wxFont *) NULL ;
35538 void *argp1 = 0 ;
35539 int res1 = 0 ;
35540 bool temp2 = false ;
35541 int temp3 ;
35542 int res3 = SWIG_TMPOBJ ;
35543 int temp4 ;
35544 int res4 = SWIG_TMPOBJ ;
35545 int temp5 ;
35546 int res5 = SWIG_TMPOBJ ;
35547 int temp6 ;
35548 int res6 = SWIG_TMPOBJ ;
35549 void *argp7 = 0 ;
35550 int res7 = 0 ;
35551 PyObject * obj0 = 0 ;
35552 PyObject * obj1 = 0 ;
35553 PyObject * obj2 = 0 ;
35554 char * kwnames[] = {
35555 (char *) "self",(char *) "string",(char *) "font", NULL
35556 };
35557
35558 arg3 = &temp3;
35559 arg4 = &temp4;
35560 arg5 = &temp5;
35561 arg6 = &temp6;
35562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35564 if (!SWIG_IsOK(res1)) {
35565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35566 }
35567 arg1 = reinterpret_cast< wxWindow * >(argp1);
35568 {
35569 arg2 = wxString_in_helper(obj1);
35570 if (arg2 == NULL) SWIG_fail;
35571 temp2 = true;
35572 }
35573 if (obj2) {
35574 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35575 if (!SWIG_IsOK(res7)) {
35576 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35577 }
35578 arg7 = reinterpret_cast< wxFont * >(argp7);
35579 }
35580 {
35581 PyThreadState* __tstate = wxPyBeginAllowThreads();
35582 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35583 wxPyEndAllowThreads(__tstate);
35584 if (PyErr_Occurred()) SWIG_fail;
35585 }
35586 resultobj = SWIG_Py_Void();
35587 if (SWIG_IsTmpObj(res3)) {
35588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35589 } else {
35590 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35591 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35592 }
35593 if (SWIG_IsTmpObj(res4)) {
35594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35595 } else {
35596 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35598 }
35599 if (SWIG_IsTmpObj(res5)) {
35600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35601 } else {
35602 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35604 }
35605 if (SWIG_IsTmpObj(res6)) {
35606 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35607 } else {
35608 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35610 }
35611 {
35612 if (temp2)
35613 delete arg2;
35614 }
35615 return resultobj;
35616 fail:
35617 {
35618 if (temp2)
35619 delete arg2;
35620 }
35621 return NULL;
35622 }
35623
35624
35625 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35626 PyObject *resultobj = 0;
35627 wxWindow *arg1 = (wxWindow *) 0 ;
35628 int *arg2 = (int *) 0 ;
35629 int *arg3 = (int *) 0 ;
35630 void *argp1 = 0 ;
35631 int res1 = 0 ;
35632 int temp2 ;
35633 int res2 = 0 ;
35634 int temp3 ;
35635 int res3 = 0 ;
35636 PyObject * obj0 = 0 ;
35637 PyObject * obj1 = 0 ;
35638 PyObject * obj2 = 0 ;
35639 char * kwnames[] = {
35640 (char *) "self",(char *) "x",(char *) "y", NULL
35641 };
35642
35643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35645 if (!SWIG_IsOK(res1)) {
35646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35647 }
35648 arg1 = reinterpret_cast< wxWindow * >(argp1);
35649 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35650 int val;
35651 int ecode = SWIG_AsVal_int(obj1, &val);
35652 if (!SWIG_IsOK(ecode)) {
35653 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35654 }
35655 temp2 = static_cast< int >(val);
35656 arg2 = &temp2;
35657 res2 = SWIG_AddTmpMask(ecode);
35658 }
35659 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35660 int val;
35661 int ecode = SWIG_AsVal_int(obj2, &val);
35662 if (!SWIG_IsOK(ecode)) {
35663 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35664 }
35665 temp3 = static_cast< int >(val);
35666 arg3 = &temp3;
35667 res3 = SWIG_AddTmpMask(ecode);
35668 }
35669 {
35670 PyThreadState* __tstate = wxPyBeginAllowThreads();
35671 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35672 wxPyEndAllowThreads(__tstate);
35673 if (PyErr_Occurred()) SWIG_fail;
35674 }
35675 resultobj = SWIG_Py_Void();
35676 if (SWIG_IsTmpObj(res2)) {
35677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35678 } else {
35679 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35681 }
35682 if (SWIG_IsTmpObj(res3)) {
35683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35684 } else {
35685 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35687 }
35688 return resultobj;
35689 fail:
35690 return NULL;
35691 }
35692
35693
35694 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35695 PyObject *resultobj = 0;
35696 wxWindow *arg1 = (wxWindow *) 0 ;
35697 int *arg2 = (int *) 0 ;
35698 int *arg3 = (int *) 0 ;
35699 void *argp1 = 0 ;
35700 int res1 = 0 ;
35701 int temp2 ;
35702 int res2 = 0 ;
35703 int temp3 ;
35704 int res3 = 0 ;
35705 PyObject * obj0 = 0 ;
35706 PyObject * obj1 = 0 ;
35707 PyObject * obj2 = 0 ;
35708 char * kwnames[] = {
35709 (char *) "self",(char *) "x",(char *) "y", NULL
35710 };
35711
35712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35714 if (!SWIG_IsOK(res1)) {
35715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35716 }
35717 arg1 = reinterpret_cast< wxWindow * >(argp1);
35718 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35719 int val;
35720 int ecode = SWIG_AsVal_int(obj1, &val);
35721 if (!SWIG_IsOK(ecode)) {
35722 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35723 }
35724 temp2 = static_cast< int >(val);
35725 arg2 = &temp2;
35726 res2 = SWIG_AddTmpMask(ecode);
35727 }
35728 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35729 int val;
35730 int ecode = SWIG_AsVal_int(obj2, &val);
35731 if (!SWIG_IsOK(ecode)) {
35732 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35733 }
35734 temp3 = static_cast< int >(val);
35735 arg3 = &temp3;
35736 res3 = SWIG_AddTmpMask(ecode);
35737 }
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 resultobj = SWIG_Py_Void();
35745 if (SWIG_IsTmpObj(res2)) {
35746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35747 } else {
35748 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35750 }
35751 if (SWIG_IsTmpObj(res3)) {
35752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35753 } else {
35754 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35756 }
35757 return resultobj;
35758 fail:
35759 return NULL;
35760 }
35761
35762
35763 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35764 PyObject *resultobj = 0;
35765 wxWindow *arg1 = (wxWindow *) 0 ;
35766 wxPoint *arg2 = 0 ;
35767 wxPoint result;
35768 void *argp1 = 0 ;
35769 int res1 = 0 ;
35770 wxPoint temp2 ;
35771 PyObject * obj0 = 0 ;
35772 PyObject * obj1 = 0 ;
35773 char * kwnames[] = {
35774 (char *) "self",(char *) "pt", NULL
35775 };
35776
35777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35779 if (!SWIG_IsOK(res1)) {
35780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35781 }
35782 arg1 = reinterpret_cast< wxWindow * >(argp1);
35783 {
35784 arg2 = &temp2;
35785 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35786 }
35787 {
35788 PyThreadState* __tstate = wxPyBeginAllowThreads();
35789 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35790 wxPyEndAllowThreads(__tstate);
35791 if (PyErr_Occurred()) SWIG_fail;
35792 }
35793 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35794 return resultobj;
35795 fail:
35796 return NULL;
35797 }
35798
35799
35800 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35801 PyObject *resultobj = 0;
35802 wxWindow *arg1 = (wxWindow *) 0 ;
35803 wxPoint *arg2 = 0 ;
35804 wxPoint result;
35805 void *argp1 = 0 ;
35806 int res1 = 0 ;
35807 wxPoint temp2 ;
35808 PyObject * obj0 = 0 ;
35809 PyObject * obj1 = 0 ;
35810 char * kwnames[] = {
35811 (char *) "self",(char *) "pt", NULL
35812 };
35813
35814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35816 if (!SWIG_IsOK(res1)) {
35817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35818 }
35819 arg1 = reinterpret_cast< wxWindow * >(argp1);
35820 {
35821 arg2 = &temp2;
35822 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35823 }
35824 {
35825 PyThreadState* __tstate = wxPyBeginAllowThreads();
35826 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35827 wxPyEndAllowThreads(__tstate);
35828 if (PyErr_Occurred()) SWIG_fail;
35829 }
35830 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35831 return resultobj;
35832 fail:
35833 return NULL;
35834 }
35835
35836
35837 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35838 PyObject *resultobj = 0;
35839 wxWindow *arg1 = (wxWindow *) 0 ;
35840 int arg2 ;
35841 int arg3 ;
35842 wxHitTest result;
35843 void *argp1 = 0 ;
35844 int res1 = 0 ;
35845 int val2 ;
35846 int ecode2 = 0 ;
35847 int val3 ;
35848 int ecode3 = 0 ;
35849 PyObject * obj0 = 0 ;
35850 PyObject * obj1 = 0 ;
35851 PyObject * obj2 = 0 ;
35852 char * kwnames[] = {
35853 (char *) "self",(char *) "x",(char *) "y", NULL
35854 };
35855
35856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35858 if (!SWIG_IsOK(res1)) {
35859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35860 }
35861 arg1 = reinterpret_cast< wxWindow * >(argp1);
35862 ecode2 = SWIG_AsVal_int(obj1, &val2);
35863 if (!SWIG_IsOK(ecode2)) {
35864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35865 }
35866 arg2 = static_cast< int >(val2);
35867 ecode3 = SWIG_AsVal_int(obj2, &val3);
35868 if (!SWIG_IsOK(ecode3)) {
35869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35870 }
35871 arg3 = static_cast< int >(val3);
35872 {
35873 PyThreadState* __tstate = wxPyBeginAllowThreads();
35874 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35875 wxPyEndAllowThreads(__tstate);
35876 if (PyErr_Occurred()) SWIG_fail;
35877 }
35878 resultobj = SWIG_From_int(static_cast< int >(result));
35879 return resultobj;
35880 fail:
35881 return NULL;
35882 }
35883
35884
35885 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35886 PyObject *resultobj = 0;
35887 wxWindow *arg1 = (wxWindow *) 0 ;
35888 wxPoint *arg2 = 0 ;
35889 wxHitTest result;
35890 void *argp1 = 0 ;
35891 int res1 = 0 ;
35892 wxPoint temp2 ;
35893 PyObject * obj0 = 0 ;
35894 PyObject * obj1 = 0 ;
35895 char * kwnames[] = {
35896 (char *) "self",(char *) "pt", NULL
35897 };
35898
35899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35901 if (!SWIG_IsOK(res1)) {
35902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35903 }
35904 arg1 = reinterpret_cast< wxWindow * >(argp1);
35905 {
35906 arg2 = &temp2;
35907 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35908 }
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35912 wxPyEndAllowThreads(__tstate);
35913 if (PyErr_Occurred()) SWIG_fail;
35914 }
35915 resultobj = SWIG_From_int(static_cast< int >(result));
35916 return resultobj;
35917 fail:
35918 return NULL;
35919 }
35920
35921
35922 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35923 PyObject *resultobj = 0;
35924 wxWindow *arg1 = (wxWindow *) 0 ;
35925 long arg2 ;
35926 wxBorder result;
35927 void *argp1 = 0 ;
35928 int res1 = 0 ;
35929 long val2 ;
35930 int ecode2 = 0 ;
35931
35932 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35934 if (!SWIG_IsOK(res1)) {
35935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35936 }
35937 arg1 = reinterpret_cast< wxWindow * >(argp1);
35938 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35939 if (!SWIG_IsOK(ecode2)) {
35940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35941 }
35942 arg2 = static_cast< long >(val2);
35943 {
35944 PyThreadState* __tstate = wxPyBeginAllowThreads();
35945 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35946 wxPyEndAllowThreads(__tstate);
35947 if (PyErr_Occurred()) SWIG_fail;
35948 }
35949 resultobj = SWIG_From_int(static_cast< int >(result));
35950 return resultobj;
35951 fail:
35952 return NULL;
35953 }
35954
35955
35956 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35957 PyObject *resultobj = 0;
35958 wxWindow *arg1 = (wxWindow *) 0 ;
35959 wxBorder result;
35960 void *argp1 = 0 ;
35961 int res1 = 0 ;
35962
35963 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35965 if (!SWIG_IsOK(res1)) {
35966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35967 }
35968 arg1 = reinterpret_cast< wxWindow * >(argp1);
35969 {
35970 PyThreadState* __tstate = wxPyBeginAllowThreads();
35971 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35972 wxPyEndAllowThreads(__tstate);
35973 if (PyErr_Occurred()) SWIG_fail;
35974 }
35975 resultobj = SWIG_From_int(static_cast< int >(result));
35976 return resultobj;
35977 fail:
35978 return NULL;
35979 }
35980
35981
35982 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35983 int argc;
35984 PyObject *argv[3];
35985
35986 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35987 --argc;
35988 if (argc == 1) {
35989 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35990 }
35991 if (argc == 2) {
35992 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35993 }
35994
35995 fail:
35996 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35997 return NULL;
35998 }
35999
36000
36001 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36002 PyObject *resultobj = 0;
36003 wxWindow *arg1 = (wxWindow *) 0 ;
36004 long arg2 = (long) wxUPDATE_UI_NONE ;
36005 void *argp1 = 0 ;
36006 int res1 = 0 ;
36007 long val2 ;
36008 int ecode2 = 0 ;
36009 PyObject * obj0 = 0 ;
36010 PyObject * obj1 = 0 ;
36011 char * kwnames[] = {
36012 (char *) "self",(char *) "flags", NULL
36013 };
36014
36015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36017 if (!SWIG_IsOK(res1)) {
36018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36019 }
36020 arg1 = reinterpret_cast< wxWindow * >(argp1);
36021 if (obj1) {
36022 ecode2 = SWIG_AsVal_long(obj1, &val2);
36023 if (!SWIG_IsOK(ecode2)) {
36024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36025 }
36026 arg2 = static_cast< long >(val2);
36027 }
36028 {
36029 PyThreadState* __tstate = wxPyBeginAllowThreads();
36030 (arg1)->UpdateWindowUI(arg2);
36031 wxPyEndAllowThreads(__tstate);
36032 if (PyErr_Occurred()) SWIG_fail;
36033 }
36034 resultobj = SWIG_Py_Void();
36035 return resultobj;
36036 fail:
36037 return NULL;
36038 }
36039
36040
36041 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36042 PyObject *resultobj = 0;
36043 wxWindow *arg1 = (wxWindow *) 0 ;
36044 wxMenu *arg2 = (wxMenu *) 0 ;
36045 int arg3 = (int) -1 ;
36046 int arg4 = (int) -1 ;
36047 bool result;
36048 void *argp1 = 0 ;
36049 int res1 = 0 ;
36050 void *argp2 = 0 ;
36051 int res2 = 0 ;
36052 int val3 ;
36053 int ecode3 = 0 ;
36054 int val4 ;
36055 int ecode4 = 0 ;
36056 PyObject * obj0 = 0 ;
36057 PyObject * obj1 = 0 ;
36058 PyObject * obj2 = 0 ;
36059 PyObject * obj3 = 0 ;
36060 char * kwnames[] = {
36061 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36062 };
36063
36064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36066 if (!SWIG_IsOK(res1)) {
36067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36068 }
36069 arg1 = reinterpret_cast< wxWindow * >(argp1);
36070 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36071 if (!SWIG_IsOK(res2)) {
36072 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36073 }
36074 arg2 = reinterpret_cast< wxMenu * >(argp2);
36075 if (obj2) {
36076 ecode3 = SWIG_AsVal_int(obj2, &val3);
36077 if (!SWIG_IsOK(ecode3)) {
36078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36079 }
36080 arg3 = static_cast< int >(val3);
36081 }
36082 if (obj3) {
36083 ecode4 = SWIG_AsVal_int(obj3, &val4);
36084 if (!SWIG_IsOK(ecode4)) {
36085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36086 }
36087 arg4 = static_cast< int >(val4);
36088 }
36089 {
36090 PyThreadState* __tstate = wxPyBeginAllowThreads();
36091 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36092 wxPyEndAllowThreads(__tstate);
36093 if (PyErr_Occurred()) SWIG_fail;
36094 }
36095 {
36096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36097 }
36098 return resultobj;
36099 fail:
36100 return NULL;
36101 }
36102
36103
36104 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36105 PyObject *resultobj = 0;
36106 wxWindow *arg1 = (wxWindow *) 0 ;
36107 wxMenu *arg2 = (wxMenu *) 0 ;
36108 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36109 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36110 bool result;
36111 void *argp1 = 0 ;
36112 int res1 = 0 ;
36113 void *argp2 = 0 ;
36114 int res2 = 0 ;
36115 wxPoint temp3 ;
36116 PyObject * obj0 = 0 ;
36117 PyObject * obj1 = 0 ;
36118 PyObject * obj2 = 0 ;
36119 char * kwnames[] = {
36120 (char *) "self",(char *) "menu",(char *) "pos", NULL
36121 };
36122
36123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36125 if (!SWIG_IsOK(res1)) {
36126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36127 }
36128 arg1 = reinterpret_cast< wxWindow * >(argp1);
36129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36130 if (!SWIG_IsOK(res2)) {
36131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36132 }
36133 arg2 = reinterpret_cast< wxMenu * >(argp2);
36134 if (obj2) {
36135 {
36136 arg3 = &temp3;
36137 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36138 }
36139 }
36140 {
36141 PyThreadState* __tstate = wxPyBeginAllowThreads();
36142 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36143 wxPyEndAllowThreads(__tstate);
36144 if (PyErr_Occurred()) SWIG_fail;
36145 }
36146 {
36147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36148 }
36149 return resultobj;
36150 fail:
36151 return NULL;
36152 }
36153
36154
36155 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36156 PyObject *resultobj = 0;
36157 wxWindow *arg1 = (wxWindow *) 0 ;
36158 long result;
36159 void *argp1 = 0 ;
36160 int res1 = 0 ;
36161 PyObject *swig_obj[1] ;
36162
36163 if (!args) SWIG_fail;
36164 swig_obj[0] = args;
36165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36166 if (!SWIG_IsOK(res1)) {
36167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36168 }
36169 arg1 = reinterpret_cast< wxWindow * >(argp1);
36170 {
36171 PyThreadState* __tstate = wxPyBeginAllowThreads();
36172 result = (long)wxWindow_GetHandle(arg1);
36173 wxPyEndAllowThreads(__tstate);
36174 if (PyErr_Occurred()) SWIG_fail;
36175 }
36176 resultobj = SWIG_From_long(static_cast< long >(result));
36177 return resultobj;
36178 fail:
36179 return NULL;
36180 }
36181
36182
36183 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36184 PyObject *resultobj = 0;
36185 wxWindow *arg1 = (wxWindow *) 0 ;
36186 long arg2 ;
36187 void *argp1 = 0 ;
36188 int res1 = 0 ;
36189 long val2 ;
36190 int ecode2 = 0 ;
36191 PyObject * obj0 = 0 ;
36192 PyObject * obj1 = 0 ;
36193 char * kwnames[] = {
36194 (char *) "self",(char *) "handle", NULL
36195 };
36196
36197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36201 }
36202 arg1 = reinterpret_cast< wxWindow * >(argp1);
36203 ecode2 = SWIG_AsVal_long(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36206 }
36207 arg2 = static_cast< long >(val2);
36208 {
36209 PyThreadState* __tstate = wxPyBeginAllowThreads();
36210 wxWindow_AssociateHandle(arg1,arg2);
36211 wxPyEndAllowThreads(__tstate);
36212 if (PyErr_Occurred()) SWIG_fail;
36213 }
36214 resultobj = SWIG_Py_Void();
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36222 PyObject *resultobj = 0;
36223 wxWindow *arg1 = (wxWindow *) 0 ;
36224 void *argp1 = 0 ;
36225 int res1 = 0 ;
36226 PyObject *swig_obj[1] ;
36227
36228 if (!args) SWIG_fail;
36229 swig_obj[0] = args;
36230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36231 if (!SWIG_IsOK(res1)) {
36232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36233 }
36234 arg1 = reinterpret_cast< wxWindow * >(argp1);
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 (arg1)->DissociateHandle();
36238 wxPyEndAllowThreads(__tstate);
36239 if (PyErr_Occurred()) SWIG_fail;
36240 }
36241 resultobj = SWIG_Py_Void();
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36249 PyObject *resultobj = 0;
36250 wxWindow *arg1 = (wxWindow *) 0 ;
36251 wxPaintEvent *arg2 = 0 ;
36252 void *argp1 = 0 ;
36253 int res1 = 0 ;
36254 void *argp2 = 0 ;
36255 int res2 = 0 ;
36256 PyObject * obj0 = 0 ;
36257 PyObject * obj1 = 0 ;
36258 char * kwnames[] = {
36259 (char *) "self",(char *) "event", NULL
36260 };
36261
36262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36264 if (!SWIG_IsOK(res1)) {
36265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36266 }
36267 arg1 = reinterpret_cast< wxWindow * >(argp1);
36268 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36269 if (!SWIG_IsOK(res2)) {
36270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36271 }
36272 if (!argp2) {
36273 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36274 }
36275 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36276 {
36277 PyThreadState* __tstate = wxPyBeginAllowThreads();
36278 (arg1)->OnPaint(*arg2);
36279 wxPyEndAllowThreads(__tstate);
36280 if (PyErr_Occurred()) SWIG_fail;
36281 }
36282 resultobj = SWIG_Py_Void();
36283 return resultobj;
36284 fail:
36285 return NULL;
36286 }
36287
36288
36289 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36290 PyObject *resultobj = 0;
36291 wxWindow *arg1 = (wxWindow *) 0 ;
36292 int arg2 ;
36293 bool result;
36294 void *argp1 = 0 ;
36295 int res1 = 0 ;
36296 int val2 ;
36297 int ecode2 = 0 ;
36298 PyObject * obj0 = 0 ;
36299 PyObject * obj1 = 0 ;
36300 char * kwnames[] = {
36301 (char *) "self",(char *) "orient", NULL
36302 };
36303
36304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36306 if (!SWIG_IsOK(res1)) {
36307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36308 }
36309 arg1 = reinterpret_cast< wxWindow * >(argp1);
36310 ecode2 = SWIG_AsVal_int(obj1, &val2);
36311 if (!SWIG_IsOK(ecode2)) {
36312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36313 }
36314 arg2 = static_cast< int >(val2);
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 {
36322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36323 }
36324 return resultobj;
36325 fail:
36326 return NULL;
36327 }
36328
36329
36330 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36331 PyObject *resultobj = 0;
36332 wxWindow *arg1 = (wxWindow *) 0 ;
36333 int arg2 ;
36334 int arg3 ;
36335 int arg4 ;
36336 int arg5 ;
36337 bool arg6 = (bool) true ;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 int val2 ;
36341 int ecode2 = 0 ;
36342 int val3 ;
36343 int ecode3 = 0 ;
36344 int val4 ;
36345 int ecode4 = 0 ;
36346 int val5 ;
36347 int ecode5 = 0 ;
36348 bool val6 ;
36349 int ecode6 = 0 ;
36350 PyObject * obj0 = 0 ;
36351 PyObject * obj1 = 0 ;
36352 PyObject * obj2 = 0 ;
36353 PyObject * obj3 = 0 ;
36354 PyObject * obj4 = 0 ;
36355 PyObject * obj5 = 0 ;
36356 char * kwnames[] = {
36357 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36358 };
36359
36360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36362 if (!SWIG_IsOK(res1)) {
36363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36364 }
36365 arg1 = reinterpret_cast< wxWindow * >(argp1);
36366 ecode2 = SWIG_AsVal_int(obj1, &val2);
36367 if (!SWIG_IsOK(ecode2)) {
36368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36369 }
36370 arg2 = static_cast< int >(val2);
36371 ecode3 = SWIG_AsVal_int(obj2, &val3);
36372 if (!SWIG_IsOK(ecode3)) {
36373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36374 }
36375 arg3 = static_cast< int >(val3);
36376 ecode4 = SWIG_AsVal_int(obj3, &val4);
36377 if (!SWIG_IsOK(ecode4)) {
36378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36379 }
36380 arg4 = static_cast< int >(val4);
36381 ecode5 = SWIG_AsVal_int(obj4, &val5);
36382 if (!SWIG_IsOK(ecode5)) {
36383 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36384 }
36385 arg5 = static_cast< int >(val5);
36386 if (obj5) {
36387 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36388 if (!SWIG_IsOK(ecode6)) {
36389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36390 }
36391 arg6 = static_cast< bool >(val6);
36392 }
36393 {
36394 PyThreadState* __tstate = wxPyBeginAllowThreads();
36395 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36396 wxPyEndAllowThreads(__tstate);
36397 if (PyErr_Occurred()) SWIG_fail;
36398 }
36399 resultobj = SWIG_Py_Void();
36400 return resultobj;
36401 fail:
36402 return NULL;
36403 }
36404
36405
36406 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36407 PyObject *resultobj = 0;
36408 wxWindow *arg1 = (wxWindow *) 0 ;
36409 int arg2 ;
36410 int arg3 ;
36411 bool arg4 = (bool) true ;
36412 void *argp1 = 0 ;
36413 int res1 = 0 ;
36414 int val2 ;
36415 int ecode2 = 0 ;
36416 int val3 ;
36417 int ecode3 = 0 ;
36418 bool val4 ;
36419 int ecode4 = 0 ;
36420 PyObject * obj0 = 0 ;
36421 PyObject * obj1 = 0 ;
36422 PyObject * obj2 = 0 ;
36423 PyObject * obj3 = 0 ;
36424 char * kwnames[] = {
36425 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36426 };
36427
36428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36430 if (!SWIG_IsOK(res1)) {
36431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36432 }
36433 arg1 = reinterpret_cast< wxWindow * >(argp1);
36434 ecode2 = SWIG_AsVal_int(obj1, &val2);
36435 if (!SWIG_IsOK(ecode2)) {
36436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36437 }
36438 arg2 = static_cast< int >(val2);
36439 ecode3 = SWIG_AsVal_int(obj2, &val3);
36440 if (!SWIG_IsOK(ecode3)) {
36441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36442 }
36443 arg3 = static_cast< int >(val3);
36444 if (obj3) {
36445 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36446 if (!SWIG_IsOK(ecode4)) {
36447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36448 }
36449 arg4 = static_cast< bool >(val4);
36450 }
36451 {
36452 PyThreadState* __tstate = wxPyBeginAllowThreads();
36453 (arg1)->SetScrollPos(arg2,arg3,arg4);
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 resultobj = SWIG_Py_Void();
36458 return resultobj;
36459 fail:
36460 return NULL;
36461 }
36462
36463
36464 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36465 PyObject *resultobj = 0;
36466 wxWindow *arg1 = (wxWindow *) 0 ;
36467 int arg2 ;
36468 int result;
36469 void *argp1 = 0 ;
36470 int res1 = 0 ;
36471 int val2 ;
36472 int ecode2 = 0 ;
36473 PyObject * obj0 = 0 ;
36474 PyObject * obj1 = 0 ;
36475 char * kwnames[] = {
36476 (char *) "self",(char *) "orientation", NULL
36477 };
36478
36479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36481 if (!SWIG_IsOK(res1)) {
36482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36483 }
36484 arg1 = reinterpret_cast< wxWindow * >(argp1);
36485 ecode2 = SWIG_AsVal_int(obj1, &val2);
36486 if (!SWIG_IsOK(ecode2)) {
36487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36488 }
36489 arg2 = static_cast< int >(val2);
36490 {
36491 PyThreadState* __tstate = wxPyBeginAllowThreads();
36492 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36493 wxPyEndAllowThreads(__tstate);
36494 if (PyErr_Occurred()) SWIG_fail;
36495 }
36496 resultobj = SWIG_From_int(static_cast< int >(result));
36497 return resultobj;
36498 fail:
36499 return NULL;
36500 }
36501
36502
36503 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36504 PyObject *resultobj = 0;
36505 wxWindow *arg1 = (wxWindow *) 0 ;
36506 int arg2 ;
36507 int result;
36508 void *argp1 = 0 ;
36509 int res1 = 0 ;
36510 int val2 ;
36511 int ecode2 = 0 ;
36512 PyObject * obj0 = 0 ;
36513 PyObject * obj1 = 0 ;
36514 char * kwnames[] = {
36515 (char *) "self",(char *) "orientation", NULL
36516 };
36517
36518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36520 if (!SWIG_IsOK(res1)) {
36521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36522 }
36523 arg1 = reinterpret_cast< wxWindow * >(argp1);
36524 ecode2 = SWIG_AsVal_int(obj1, &val2);
36525 if (!SWIG_IsOK(ecode2)) {
36526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36527 }
36528 arg2 = static_cast< int >(val2);
36529 {
36530 PyThreadState* __tstate = wxPyBeginAllowThreads();
36531 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36532 wxPyEndAllowThreads(__tstate);
36533 if (PyErr_Occurred()) SWIG_fail;
36534 }
36535 resultobj = SWIG_From_int(static_cast< int >(result));
36536 return resultobj;
36537 fail:
36538 return NULL;
36539 }
36540
36541
36542 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36543 PyObject *resultobj = 0;
36544 wxWindow *arg1 = (wxWindow *) 0 ;
36545 int arg2 ;
36546 int result;
36547 void *argp1 = 0 ;
36548 int res1 = 0 ;
36549 int val2 ;
36550 int ecode2 = 0 ;
36551 PyObject * obj0 = 0 ;
36552 PyObject * obj1 = 0 ;
36553 char * kwnames[] = {
36554 (char *) "self",(char *) "orientation", NULL
36555 };
36556
36557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36559 if (!SWIG_IsOK(res1)) {
36560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36561 }
36562 arg1 = reinterpret_cast< wxWindow * >(argp1);
36563 ecode2 = SWIG_AsVal_int(obj1, &val2);
36564 if (!SWIG_IsOK(ecode2)) {
36565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36566 }
36567 arg2 = static_cast< int >(val2);
36568 {
36569 PyThreadState* __tstate = wxPyBeginAllowThreads();
36570 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 resultobj = SWIG_From_int(static_cast< int >(result));
36575 return resultobj;
36576 fail:
36577 return NULL;
36578 }
36579
36580
36581 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36582 PyObject *resultobj = 0;
36583 wxWindow *arg1 = (wxWindow *) 0 ;
36584 int arg2 ;
36585 int arg3 ;
36586 wxRect *arg4 = (wxRect *) NULL ;
36587 void *argp1 = 0 ;
36588 int res1 = 0 ;
36589 int val2 ;
36590 int ecode2 = 0 ;
36591 int val3 ;
36592 int ecode3 = 0 ;
36593 void *argp4 = 0 ;
36594 int res4 = 0 ;
36595 PyObject * obj0 = 0 ;
36596 PyObject * obj1 = 0 ;
36597 PyObject * obj2 = 0 ;
36598 PyObject * obj3 = 0 ;
36599 char * kwnames[] = {
36600 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36601 };
36602
36603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36605 if (!SWIG_IsOK(res1)) {
36606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36607 }
36608 arg1 = reinterpret_cast< wxWindow * >(argp1);
36609 ecode2 = SWIG_AsVal_int(obj1, &val2);
36610 if (!SWIG_IsOK(ecode2)) {
36611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36612 }
36613 arg2 = static_cast< int >(val2);
36614 ecode3 = SWIG_AsVal_int(obj2, &val3);
36615 if (!SWIG_IsOK(ecode3)) {
36616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36617 }
36618 arg3 = static_cast< int >(val3);
36619 if (obj3) {
36620 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36621 if (!SWIG_IsOK(res4)) {
36622 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36623 }
36624 arg4 = reinterpret_cast< wxRect * >(argp4);
36625 }
36626 {
36627 PyThreadState* __tstate = wxPyBeginAllowThreads();
36628 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36629 wxPyEndAllowThreads(__tstate);
36630 if (PyErr_Occurred()) SWIG_fail;
36631 }
36632 resultobj = SWIG_Py_Void();
36633 return resultobj;
36634 fail:
36635 return NULL;
36636 }
36637
36638
36639 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36640 PyObject *resultobj = 0;
36641 wxWindow *arg1 = (wxWindow *) 0 ;
36642 int arg2 ;
36643 bool result;
36644 void *argp1 = 0 ;
36645 int res1 = 0 ;
36646 int val2 ;
36647 int ecode2 = 0 ;
36648 PyObject * obj0 = 0 ;
36649 PyObject * obj1 = 0 ;
36650 char * kwnames[] = {
36651 (char *) "self",(char *) "lines", NULL
36652 };
36653
36654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36656 if (!SWIG_IsOK(res1)) {
36657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36658 }
36659 arg1 = reinterpret_cast< wxWindow * >(argp1);
36660 ecode2 = SWIG_AsVal_int(obj1, &val2);
36661 if (!SWIG_IsOK(ecode2)) {
36662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36663 }
36664 arg2 = static_cast< int >(val2);
36665 {
36666 PyThreadState* __tstate = wxPyBeginAllowThreads();
36667 result = (bool)(arg1)->ScrollLines(arg2);
36668 wxPyEndAllowThreads(__tstate);
36669 if (PyErr_Occurred()) SWIG_fail;
36670 }
36671 {
36672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36673 }
36674 return resultobj;
36675 fail:
36676 return NULL;
36677 }
36678
36679
36680 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36681 PyObject *resultobj = 0;
36682 wxWindow *arg1 = (wxWindow *) 0 ;
36683 int arg2 ;
36684 bool result;
36685 void *argp1 = 0 ;
36686 int res1 = 0 ;
36687 int val2 ;
36688 int ecode2 = 0 ;
36689 PyObject * obj0 = 0 ;
36690 PyObject * obj1 = 0 ;
36691 char * kwnames[] = {
36692 (char *) "self",(char *) "pages", NULL
36693 };
36694
36695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36697 if (!SWIG_IsOK(res1)) {
36698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36699 }
36700 arg1 = reinterpret_cast< wxWindow * >(argp1);
36701 ecode2 = SWIG_AsVal_int(obj1, &val2);
36702 if (!SWIG_IsOK(ecode2)) {
36703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36704 }
36705 arg2 = static_cast< int >(val2);
36706 {
36707 PyThreadState* __tstate = wxPyBeginAllowThreads();
36708 result = (bool)(arg1)->ScrollPages(arg2);
36709 wxPyEndAllowThreads(__tstate);
36710 if (PyErr_Occurred()) SWIG_fail;
36711 }
36712 {
36713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36714 }
36715 return resultobj;
36716 fail:
36717 return NULL;
36718 }
36719
36720
36721 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36722 PyObject *resultobj = 0;
36723 wxWindow *arg1 = (wxWindow *) 0 ;
36724 bool result;
36725 void *argp1 = 0 ;
36726 int res1 = 0 ;
36727 PyObject *swig_obj[1] ;
36728
36729 if (!args) SWIG_fail;
36730 swig_obj[0] = args;
36731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36732 if (!SWIG_IsOK(res1)) {
36733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36734 }
36735 arg1 = reinterpret_cast< wxWindow * >(argp1);
36736 {
36737 PyThreadState* __tstate = wxPyBeginAllowThreads();
36738 result = (bool)(arg1)->LineUp();
36739 wxPyEndAllowThreads(__tstate);
36740 if (PyErr_Occurred()) SWIG_fail;
36741 }
36742 {
36743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36744 }
36745 return resultobj;
36746 fail:
36747 return NULL;
36748 }
36749
36750
36751 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36752 PyObject *resultobj = 0;
36753 wxWindow *arg1 = (wxWindow *) 0 ;
36754 bool result;
36755 void *argp1 = 0 ;
36756 int res1 = 0 ;
36757 PyObject *swig_obj[1] ;
36758
36759 if (!args) SWIG_fail;
36760 swig_obj[0] = args;
36761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36762 if (!SWIG_IsOK(res1)) {
36763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36764 }
36765 arg1 = reinterpret_cast< wxWindow * >(argp1);
36766 {
36767 PyThreadState* __tstate = wxPyBeginAllowThreads();
36768 result = (bool)(arg1)->LineDown();
36769 wxPyEndAllowThreads(__tstate);
36770 if (PyErr_Occurred()) SWIG_fail;
36771 }
36772 {
36773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36774 }
36775 return resultobj;
36776 fail:
36777 return NULL;
36778 }
36779
36780
36781 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36782 PyObject *resultobj = 0;
36783 wxWindow *arg1 = (wxWindow *) 0 ;
36784 bool result;
36785 void *argp1 = 0 ;
36786 int res1 = 0 ;
36787 PyObject *swig_obj[1] ;
36788
36789 if (!args) SWIG_fail;
36790 swig_obj[0] = args;
36791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36792 if (!SWIG_IsOK(res1)) {
36793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36794 }
36795 arg1 = reinterpret_cast< wxWindow * >(argp1);
36796 {
36797 PyThreadState* __tstate = wxPyBeginAllowThreads();
36798 result = (bool)(arg1)->PageUp();
36799 wxPyEndAllowThreads(__tstate);
36800 if (PyErr_Occurred()) SWIG_fail;
36801 }
36802 {
36803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36804 }
36805 return resultobj;
36806 fail:
36807 return NULL;
36808 }
36809
36810
36811 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36812 PyObject *resultobj = 0;
36813 wxWindow *arg1 = (wxWindow *) 0 ;
36814 bool result;
36815 void *argp1 = 0 ;
36816 int res1 = 0 ;
36817 PyObject *swig_obj[1] ;
36818
36819 if (!args) SWIG_fail;
36820 swig_obj[0] = args;
36821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36822 if (!SWIG_IsOK(res1)) {
36823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36824 }
36825 arg1 = reinterpret_cast< wxWindow * >(argp1);
36826 {
36827 PyThreadState* __tstate = wxPyBeginAllowThreads();
36828 result = (bool)(arg1)->PageDown();
36829 wxPyEndAllowThreads(__tstate);
36830 if (PyErr_Occurred()) SWIG_fail;
36831 }
36832 {
36833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36834 }
36835 return resultobj;
36836 fail:
36837 return NULL;
36838 }
36839
36840
36841 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36842 PyObject *resultobj = 0;
36843 wxWindow *arg1 = (wxWindow *) 0 ;
36844 wxString *arg2 = 0 ;
36845 void *argp1 = 0 ;
36846 int res1 = 0 ;
36847 bool temp2 = false ;
36848 PyObject * obj0 = 0 ;
36849 PyObject * obj1 = 0 ;
36850 char * kwnames[] = {
36851 (char *) "self",(char *) "text", NULL
36852 };
36853
36854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36856 if (!SWIG_IsOK(res1)) {
36857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36858 }
36859 arg1 = reinterpret_cast< wxWindow * >(argp1);
36860 {
36861 arg2 = wxString_in_helper(obj1);
36862 if (arg2 == NULL) SWIG_fail;
36863 temp2 = true;
36864 }
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 (arg1)->SetHelpText((wxString const &)*arg2);
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 resultobj = SWIG_Py_Void();
36872 {
36873 if (temp2)
36874 delete arg2;
36875 }
36876 return resultobj;
36877 fail:
36878 {
36879 if (temp2)
36880 delete arg2;
36881 }
36882 return NULL;
36883 }
36884
36885
36886 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36887 PyObject *resultobj = 0;
36888 wxWindow *arg1 = (wxWindow *) 0 ;
36889 wxString *arg2 = 0 ;
36890 void *argp1 = 0 ;
36891 int res1 = 0 ;
36892 bool temp2 = false ;
36893 PyObject * obj0 = 0 ;
36894 PyObject * obj1 = 0 ;
36895 char * kwnames[] = {
36896 (char *) "self",(char *) "text", NULL
36897 };
36898
36899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36903 }
36904 arg1 = reinterpret_cast< wxWindow * >(argp1);
36905 {
36906 arg2 = wxString_in_helper(obj1);
36907 if (arg2 == NULL) SWIG_fail;
36908 temp2 = true;
36909 }
36910 {
36911 PyThreadState* __tstate = wxPyBeginAllowThreads();
36912 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 resultobj = SWIG_Py_Void();
36917 {
36918 if (temp2)
36919 delete arg2;
36920 }
36921 return resultobj;
36922 fail:
36923 {
36924 if (temp2)
36925 delete arg2;
36926 }
36927 return NULL;
36928 }
36929
36930
36931 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36932 PyObject *resultobj = 0;
36933 wxWindow *arg1 = (wxWindow *) 0 ;
36934 wxPoint *arg2 = 0 ;
36935 wxHelpEvent::Origin arg3 ;
36936 wxString result;
36937 void *argp1 = 0 ;
36938 int res1 = 0 ;
36939 wxPoint temp2 ;
36940 void *argp3 ;
36941 int res3 = 0 ;
36942 PyObject * obj0 = 0 ;
36943 PyObject * obj1 = 0 ;
36944 PyObject * obj2 = 0 ;
36945 char * kwnames[] = {
36946 (char *) "self",(char *) "pt",(char *) "origin", NULL
36947 };
36948
36949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36951 if (!SWIG_IsOK(res1)) {
36952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36953 }
36954 arg1 = reinterpret_cast< wxWindow * >(argp1);
36955 {
36956 arg2 = &temp2;
36957 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36958 }
36959 {
36960 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36961 if (!SWIG_IsOK(res3)) {
36962 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36963 }
36964 if (!argp3) {
36965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36966 } else {
36967 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
36968 arg3 = *temp;
36969 if (SWIG_IsNewObj(res3)) delete temp;
36970 }
36971 }
36972 {
36973 PyThreadState* __tstate = wxPyBeginAllowThreads();
36974 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
36975 wxPyEndAllowThreads(__tstate);
36976 if (PyErr_Occurred()) SWIG_fail;
36977 }
36978 {
36979 #if wxUSE_UNICODE
36980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36981 #else
36982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36983 #endif
36984 }
36985 return resultobj;
36986 fail:
36987 return NULL;
36988 }
36989
36990
36991 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36992 PyObject *resultobj = 0;
36993 wxWindow *arg1 = (wxWindow *) 0 ;
36994 wxString result;
36995 void *argp1 = 0 ;
36996 int res1 = 0 ;
36997 PyObject *swig_obj[1] ;
36998
36999 if (!args) SWIG_fail;
37000 swig_obj[0] = args;
37001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37002 if (!SWIG_IsOK(res1)) {
37003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37004 }
37005 arg1 = reinterpret_cast< wxWindow * >(argp1);
37006 {
37007 PyThreadState* __tstate = wxPyBeginAllowThreads();
37008 result = ((wxWindow const *)arg1)->GetHelpText();
37009 wxPyEndAllowThreads(__tstate);
37010 if (PyErr_Occurred()) SWIG_fail;
37011 }
37012 {
37013 #if wxUSE_UNICODE
37014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37015 #else
37016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37017 #endif
37018 }
37019 return resultobj;
37020 fail:
37021 return NULL;
37022 }
37023
37024
37025 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37026 PyObject *resultobj = 0;
37027 wxWindow *arg1 = (wxWindow *) 0 ;
37028 wxString *arg2 = 0 ;
37029 void *argp1 = 0 ;
37030 int res1 = 0 ;
37031 bool temp2 = false ;
37032 PyObject * obj0 = 0 ;
37033 PyObject * obj1 = 0 ;
37034 char * kwnames[] = {
37035 (char *) "self",(char *) "tip", NULL
37036 };
37037
37038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37040 if (!SWIG_IsOK(res1)) {
37041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37042 }
37043 arg1 = reinterpret_cast< wxWindow * >(argp1);
37044 {
37045 arg2 = wxString_in_helper(obj1);
37046 if (arg2 == NULL) SWIG_fail;
37047 temp2 = true;
37048 }
37049 {
37050 PyThreadState* __tstate = wxPyBeginAllowThreads();
37051 (arg1)->SetToolTip((wxString const &)*arg2);
37052 wxPyEndAllowThreads(__tstate);
37053 if (PyErr_Occurred()) SWIG_fail;
37054 }
37055 resultobj = SWIG_Py_Void();
37056 {
37057 if (temp2)
37058 delete arg2;
37059 }
37060 return resultobj;
37061 fail:
37062 {
37063 if (temp2)
37064 delete arg2;
37065 }
37066 return NULL;
37067 }
37068
37069
37070 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj = 0;
37072 wxWindow *arg1 = (wxWindow *) 0 ;
37073 wxToolTip *arg2 = (wxToolTip *) 0 ;
37074 void *argp1 = 0 ;
37075 int res1 = 0 ;
37076 int res2 = 0 ;
37077 PyObject * obj0 = 0 ;
37078 PyObject * obj1 = 0 ;
37079 char * kwnames[] = {
37080 (char *) "self",(char *) "tip", NULL
37081 };
37082
37083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37085 if (!SWIG_IsOK(res1)) {
37086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37087 }
37088 arg1 = reinterpret_cast< wxWindow * >(argp1);
37089 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37090 if (!SWIG_IsOK(res2)) {
37091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37092 }
37093 {
37094 PyThreadState* __tstate = wxPyBeginAllowThreads();
37095 (arg1)->SetToolTip(arg2);
37096 wxPyEndAllowThreads(__tstate);
37097 if (PyErr_Occurred()) SWIG_fail;
37098 }
37099 resultobj = SWIG_Py_Void();
37100 return resultobj;
37101 fail:
37102 return NULL;
37103 }
37104
37105
37106 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37107 PyObject *resultobj = 0;
37108 wxWindow *arg1 = (wxWindow *) 0 ;
37109 wxToolTip *result = 0 ;
37110 void *argp1 = 0 ;
37111 int res1 = 0 ;
37112 PyObject *swig_obj[1] ;
37113
37114 if (!args) SWIG_fail;
37115 swig_obj[0] = args;
37116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37117 if (!SWIG_IsOK(res1)) {
37118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37119 }
37120 arg1 = reinterpret_cast< wxWindow * >(argp1);
37121 {
37122 PyThreadState* __tstate = wxPyBeginAllowThreads();
37123 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37124 wxPyEndAllowThreads(__tstate);
37125 if (PyErr_Occurred()) SWIG_fail;
37126 }
37127 {
37128 resultobj = wxPyMake_wxObject(result, (bool)0);
37129 }
37130 return resultobj;
37131 fail:
37132 return NULL;
37133 }
37134
37135
37136 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37137 PyObject *resultobj = 0;
37138 wxWindow *arg1 = (wxWindow *) 0 ;
37139 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37140 void *argp1 = 0 ;
37141 int res1 = 0 ;
37142 int res2 = 0 ;
37143 PyObject * obj0 = 0 ;
37144 PyObject * obj1 = 0 ;
37145 char * kwnames[] = {
37146 (char *) "self",(char *) "dropTarget", NULL
37147 };
37148
37149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37151 if (!SWIG_IsOK(res1)) {
37152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37153 }
37154 arg1 = reinterpret_cast< wxWindow * >(argp1);
37155 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37156 if (!SWIG_IsOK(res2)) {
37157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37158 }
37159 {
37160 PyThreadState* __tstate = wxPyBeginAllowThreads();
37161 (arg1)->SetDropTarget(arg2);
37162 wxPyEndAllowThreads(__tstate);
37163 if (PyErr_Occurred()) SWIG_fail;
37164 }
37165 resultobj = SWIG_Py_Void();
37166 return resultobj;
37167 fail:
37168 return NULL;
37169 }
37170
37171
37172 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37173 PyObject *resultobj = 0;
37174 wxWindow *arg1 = (wxWindow *) 0 ;
37175 wxPyDropTarget *result = 0 ;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 PyObject *swig_obj[1] ;
37179
37180 if (!args) SWIG_fail;
37181 swig_obj[0] = args;
37182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37183 if (!SWIG_IsOK(res1)) {
37184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37185 }
37186 arg1 = reinterpret_cast< wxWindow * >(argp1);
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37194 return resultobj;
37195 fail:
37196 return NULL;
37197 }
37198
37199
37200 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37201 PyObject *resultobj = 0;
37202 wxWindow *arg1 = (wxWindow *) 0 ;
37203 bool arg2 ;
37204 void *argp1 = 0 ;
37205 int res1 = 0 ;
37206 bool val2 ;
37207 int ecode2 = 0 ;
37208 PyObject * obj0 = 0 ;
37209 PyObject * obj1 = 0 ;
37210 char * kwnames[] = {
37211 (char *) "self",(char *) "accept", NULL
37212 };
37213
37214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37216 if (!SWIG_IsOK(res1)) {
37217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37218 }
37219 arg1 = reinterpret_cast< wxWindow * >(argp1);
37220 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37221 if (!SWIG_IsOK(ecode2)) {
37222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37223 }
37224 arg2 = static_cast< bool >(val2);
37225 {
37226 PyThreadState* __tstate = wxPyBeginAllowThreads();
37227 (arg1)->DragAcceptFiles(arg2);
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 resultobj = SWIG_Py_Void();
37232 return resultobj;
37233 fail:
37234 return NULL;
37235 }
37236
37237
37238 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37239 PyObject *resultobj = 0;
37240 wxWindow *arg1 = (wxWindow *) 0 ;
37241 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37242 void *argp1 = 0 ;
37243 int res1 = 0 ;
37244 int res2 = 0 ;
37245 PyObject * obj0 = 0 ;
37246 PyObject * obj1 = 0 ;
37247 char * kwnames[] = {
37248 (char *) "self",(char *) "constraints", NULL
37249 };
37250
37251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37253 if (!SWIG_IsOK(res1)) {
37254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37255 }
37256 arg1 = reinterpret_cast< wxWindow * >(argp1);
37257 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37258 if (!SWIG_IsOK(res2)) {
37259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37260 }
37261 {
37262 PyThreadState* __tstate = wxPyBeginAllowThreads();
37263 (arg1)->SetConstraints(arg2);
37264 wxPyEndAllowThreads(__tstate);
37265 if (PyErr_Occurred()) SWIG_fail;
37266 }
37267 resultobj = SWIG_Py_Void();
37268 return resultobj;
37269 fail:
37270 return NULL;
37271 }
37272
37273
37274 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37275 PyObject *resultobj = 0;
37276 wxWindow *arg1 = (wxWindow *) 0 ;
37277 wxLayoutConstraints *result = 0 ;
37278 void *argp1 = 0 ;
37279 int res1 = 0 ;
37280 PyObject *swig_obj[1] ;
37281
37282 if (!args) SWIG_fail;
37283 swig_obj[0] = args;
37284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37285 if (!SWIG_IsOK(res1)) {
37286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37287 }
37288 arg1 = reinterpret_cast< wxWindow * >(argp1);
37289 {
37290 PyThreadState* __tstate = wxPyBeginAllowThreads();
37291 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37292 wxPyEndAllowThreads(__tstate);
37293 if (PyErr_Occurred()) SWIG_fail;
37294 }
37295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37296 return resultobj;
37297 fail:
37298 return NULL;
37299 }
37300
37301
37302 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37303 PyObject *resultobj = 0;
37304 wxWindow *arg1 = (wxWindow *) 0 ;
37305 bool arg2 ;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 bool val2 ;
37309 int ecode2 = 0 ;
37310 PyObject * obj0 = 0 ;
37311 PyObject * obj1 = 0 ;
37312 char * kwnames[] = {
37313 (char *) "self",(char *) "autoLayout", NULL
37314 };
37315
37316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37318 if (!SWIG_IsOK(res1)) {
37319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37320 }
37321 arg1 = reinterpret_cast< wxWindow * >(argp1);
37322 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37323 if (!SWIG_IsOK(ecode2)) {
37324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37325 }
37326 arg2 = static_cast< bool >(val2);
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 (arg1)->SetAutoLayout(arg2);
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 resultobj = SWIG_Py_Void();
37334 return resultobj;
37335 fail:
37336 return NULL;
37337 }
37338
37339
37340 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37341 PyObject *resultobj = 0;
37342 wxWindow *arg1 = (wxWindow *) 0 ;
37343 bool result;
37344 void *argp1 = 0 ;
37345 int res1 = 0 ;
37346 PyObject *swig_obj[1] ;
37347
37348 if (!args) SWIG_fail;
37349 swig_obj[0] = args;
37350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37351 if (!SWIG_IsOK(res1)) {
37352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37353 }
37354 arg1 = reinterpret_cast< wxWindow * >(argp1);
37355 {
37356 PyThreadState* __tstate = wxPyBeginAllowThreads();
37357 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37358 wxPyEndAllowThreads(__tstate);
37359 if (PyErr_Occurred()) SWIG_fail;
37360 }
37361 {
37362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37363 }
37364 return resultobj;
37365 fail:
37366 return NULL;
37367 }
37368
37369
37370 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37371 PyObject *resultobj = 0;
37372 wxWindow *arg1 = (wxWindow *) 0 ;
37373 bool result;
37374 void *argp1 = 0 ;
37375 int res1 = 0 ;
37376 PyObject *swig_obj[1] ;
37377
37378 if (!args) SWIG_fail;
37379 swig_obj[0] = args;
37380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37381 if (!SWIG_IsOK(res1)) {
37382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37383 }
37384 arg1 = reinterpret_cast< wxWindow * >(argp1);
37385 {
37386 PyThreadState* __tstate = wxPyBeginAllowThreads();
37387 result = (bool)(arg1)->Layout();
37388 wxPyEndAllowThreads(__tstate);
37389 if (PyErr_Occurred()) SWIG_fail;
37390 }
37391 {
37392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37393 }
37394 return resultobj;
37395 fail:
37396 return NULL;
37397 }
37398
37399
37400 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37401 PyObject *resultobj = 0;
37402 wxWindow *arg1 = (wxWindow *) 0 ;
37403 wxSizer *arg2 = (wxSizer *) 0 ;
37404 bool arg3 = (bool) true ;
37405 void *argp1 = 0 ;
37406 int res1 = 0 ;
37407 int res2 = 0 ;
37408 bool val3 ;
37409 int ecode3 = 0 ;
37410 PyObject * obj0 = 0 ;
37411 PyObject * obj1 = 0 ;
37412 PyObject * obj2 = 0 ;
37413 char * kwnames[] = {
37414 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37415 };
37416
37417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37419 if (!SWIG_IsOK(res1)) {
37420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37421 }
37422 arg1 = reinterpret_cast< wxWindow * >(argp1);
37423 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37424 if (!SWIG_IsOK(res2)) {
37425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37426 }
37427 if (obj2) {
37428 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37429 if (!SWIG_IsOK(ecode3)) {
37430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37431 }
37432 arg3 = static_cast< bool >(val3);
37433 }
37434 {
37435 PyThreadState* __tstate = wxPyBeginAllowThreads();
37436 (arg1)->SetSizer(arg2,arg3);
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 resultobj = SWIG_Py_Void();
37441 return resultobj;
37442 fail:
37443 return NULL;
37444 }
37445
37446
37447 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37448 PyObject *resultobj = 0;
37449 wxWindow *arg1 = (wxWindow *) 0 ;
37450 wxSizer *arg2 = (wxSizer *) 0 ;
37451 bool arg3 = (bool) true ;
37452 void *argp1 = 0 ;
37453 int res1 = 0 ;
37454 int res2 = 0 ;
37455 bool val3 ;
37456 int ecode3 = 0 ;
37457 PyObject * obj0 = 0 ;
37458 PyObject * obj1 = 0 ;
37459 PyObject * obj2 = 0 ;
37460 char * kwnames[] = {
37461 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37462 };
37463
37464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37466 if (!SWIG_IsOK(res1)) {
37467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37468 }
37469 arg1 = reinterpret_cast< wxWindow * >(argp1);
37470 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37471 if (!SWIG_IsOK(res2)) {
37472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37473 }
37474 if (obj2) {
37475 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37476 if (!SWIG_IsOK(ecode3)) {
37477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37478 }
37479 arg3 = static_cast< bool >(val3);
37480 }
37481 {
37482 PyThreadState* __tstate = wxPyBeginAllowThreads();
37483 (arg1)->SetSizerAndFit(arg2,arg3);
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 resultobj = SWIG_Py_Void();
37488 return resultobj;
37489 fail:
37490 return NULL;
37491 }
37492
37493
37494 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37495 PyObject *resultobj = 0;
37496 wxWindow *arg1 = (wxWindow *) 0 ;
37497 wxSizer *result = 0 ;
37498 void *argp1 = 0 ;
37499 int res1 = 0 ;
37500 PyObject *swig_obj[1] ;
37501
37502 if (!args) SWIG_fail;
37503 swig_obj[0] = args;
37504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37505 if (!SWIG_IsOK(res1)) {
37506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37507 }
37508 arg1 = reinterpret_cast< wxWindow * >(argp1);
37509 {
37510 PyThreadState* __tstate = wxPyBeginAllowThreads();
37511 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37512 wxPyEndAllowThreads(__tstate);
37513 if (PyErr_Occurred()) SWIG_fail;
37514 }
37515 {
37516 resultobj = wxPyMake_wxObject(result, (bool)0);
37517 }
37518 return resultobj;
37519 fail:
37520 return NULL;
37521 }
37522
37523
37524 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37525 PyObject *resultobj = 0;
37526 wxWindow *arg1 = (wxWindow *) 0 ;
37527 wxSizer *arg2 = (wxSizer *) 0 ;
37528 void *argp1 = 0 ;
37529 int res1 = 0 ;
37530 void *argp2 = 0 ;
37531 int res2 = 0 ;
37532 PyObject * obj0 = 0 ;
37533 PyObject * obj1 = 0 ;
37534 char * kwnames[] = {
37535 (char *) "self",(char *) "sizer", NULL
37536 };
37537
37538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37540 if (!SWIG_IsOK(res1)) {
37541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37542 }
37543 arg1 = reinterpret_cast< wxWindow * >(argp1);
37544 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37545 if (!SWIG_IsOK(res2)) {
37546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37547 }
37548 arg2 = reinterpret_cast< wxSizer * >(argp2);
37549 {
37550 PyThreadState* __tstate = wxPyBeginAllowThreads();
37551 (arg1)->SetContainingSizer(arg2);
37552 wxPyEndAllowThreads(__tstate);
37553 if (PyErr_Occurred()) SWIG_fail;
37554 }
37555 resultobj = SWIG_Py_Void();
37556 return resultobj;
37557 fail:
37558 return NULL;
37559 }
37560
37561
37562 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37563 PyObject *resultobj = 0;
37564 wxWindow *arg1 = (wxWindow *) 0 ;
37565 wxSizer *result = 0 ;
37566 void *argp1 = 0 ;
37567 int res1 = 0 ;
37568 PyObject *swig_obj[1] ;
37569
37570 if (!args) SWIG_fail;
37571 swig_obj[0] = args;
37572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37573 if (!SWIG_IsOK(res1)) {
37574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37575 }
37576 arg1 = reinterpret_cast< wxWindow * >(argp1);
37577 {
37578 PyThreadState* __tstate = wxPyBeginAllowThreads();
37579 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37580 wxPyEndAllowThreads(__tstate);
37581 if (PyErr_Occurred()) SWIG_fail;
37582 }
37583 {
37584 resultobj = wxPyMake_wxObject(result, (bool)0);
37585 }
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37593 PyObject *resultobj = 0;
37594 wxWindow *arg1 = (wxWindow *) 0 ;
37595 void *argp1 = 0 ;
37596 int res1 = 0 ;
37597 PyObject *swig_obj[1] ;
37598
37599 if (!args) SWIG_fail;
37600 swig_obj[0] = args;
37601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37602 if (!SWIG_IsOK(res1)) {
37603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37604 }
37605 arg1 = reinterpret_cast< wxWindow * >(argp1);
37606 {
37607 PyThreadState* __tstate = wxPyBeginAllowThreads();
37608 (arg1)->InheritAttributes();
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 resultobj = SWIG_Py_Void();
37613 return resultobj;
37614 fail:
37615 return NULL;
37616 }
37617
37618
37619 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37620 PyObject *resultobj = 0;
37621 wxWindow *arg1 = (wxWindow *) 0 ;
37622 bool result;
37623 void *argp1 = 0 ;
37624 int res1 = 0 ;
37625 PyObject *swig_obj[1] ;
37626
37627 if (!args) SWIG_fail;
37628 swig_obj[0] = args;
37629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37630 if (!SWIG_IsOK(res1)) {
37631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37632 }
37633 arg1 = reinterpret_cast< wxWindow * >(argp1);
37634 {
37635 PyThreadState* __tstate = wxPyBeginAllowThreads();
37636 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37637 wxPyEndAllowThreads(__tstate);
37638 if (PyErr_Occurred()) SWIG_fail;
37639 }
37640 {
37641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37642 }
37643 return resultobj;
37644 fail:
37645 return NULL;
37646 }
37647
37648
37649 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37650 PyObject *obj;
37651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37652 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37653 return SWIG_Py_Void();
37654 }
37655
37656 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37657 return SWIG_Python_InitShadowInstance(args);
37658 }
37659
37660 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37661 PyObject *resultobj = 0;
37662 long arg1 ;
37663 wxWindow *arg2 = (wxWindow *) NULL ;
37664 wxWindow *result = 0 ;
37665 long val1 ;
37666 int ecode1 = 0 ;
37667 void *argp2 = 0 ;
37668 int res2 = 0 ;
37669 PyObject * obj0 = 0 ;
37670 PyObject * obj1 = 0 ;
37671 char * kwnames[] = {
37672 (char *) "id",(char *) "parent", NULL
37673 };
37674
37675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37676 ecode1 = SWIG_AsVal_long(obj0, &val1);
37677 if (!SWIG_IsOK(ecode1)) {
37678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37679 }
37680 arg1 = static_cast< long >(val1);
37681 if (obj1) {
37682 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37683 if (!SWIG_IsOK(res2)) {
37684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37685 }
37686 arg2 = reinterpret_cast< wxWindow * >(argp2);
37687 }
37688 {
37689 if (!wxPyCheckForApp()) SWIG_fail;
37690 PyThreadState* __tstate = wxPyBeginAllowThreads();
37691 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37692 wxPyEndAllowThreads(__tstate);
37693 if (PyErr_Occurred()) SWIG_fail;
37694 }
37695 {
37696 resultobj = wxPyMake_wxObject(result, 0);
37697 }
37698 return resultobj;
37699 fail:
37700 return NULL;
37701 }
37702
37703
37704 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37705 PyObject *resultobj = 0;
37706 wxString *arg1 = 0 ;
37707 wxWindow *arg2 = (wxWindow *) NULL ;
37708 wxWindow *result = 0 ;
37709 bool temp1 = false ;
37710 void *argp2 = 0 ;
37711 int res2 = 0 ;
37712 PyObject * obj0 = 0 ;
37713 PyObject * obj1 = 0 ;
37714 char * kwnames[] = {
37715 (char *) "name",(char *) "parent", NULL
37716 };
37717
37718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37719 {
37720 arg1 = wxString_in_helper(obj0);
37721 if (arg1 == NULL) SWIG_fail;
37722 temp1 = true;
37723 }
37724 if (obj1) {
37725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37726 if (!SWIG_IsOK(res2)) {
37727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37728 }
37729 arg2 = reinterpret_cast< wxWindow * >(argp2);
37730 }
37731 {
37732 if (!wxPyCheckForApp()) SWIG_fail;
37733 PyThreadState* __tstate = wxPyBeginAllowThreads();
37734 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37735 wxPyEndAllowThreads(__tstate);
37736 if (PyErr_Occurred()) SWIG_fail;
37737 }
37738 {
37739 resultobj = wxPyMake_wxObject(result, 0);
37740 }
37741 {
37742 if (temp1)
37743 delete arg1;
37744 }
37745 return resultobj;
37746 fail:
37747 {
37748 if (temp1)
37749 delete arg1;
37750 }
37751 return NULL;
37752 }
37753
37754
37755 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37756 PyObject *resultobj = 0;
37757 wxString *arg1 = 0 ;
37758 wxWindow *arg2 = (wxWindow *) NULL ;
37759 wxWindow *result = 0 ;
37760 bool temp1 = false ;
37761 void *argp2 = 0 ;
37762 int res2 = 0 ;
37763 PyObject * obj0 = 0 ;
37764 PyObject * obj1 = 0 ;
37765 char * kwnames[] = {
37766 (char *) "label",(char *) "parent", NULL
37767 };
37768
37769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37770 {
37771 arg1 = wxString_in_helper(obj0);
37772 if (arg1 == NULL) SWIG_fail;
37773 temp1 = true;
37774 }
37775 if (obj1) {
37776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37777 if (!SWIG_IsOK(res2)) {
37778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37779 }
37780 arg2 = reinterpret_cast< wxWindow * >(argp2);
37781 }
37782 {
37783 if (!wxPyCheckForApp()) SWIG_fail;
37784 PyThreadState* __tstate = wxPyBeginAllowThreads();
37785 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37786 wxPyEndAllowThreads(__tstate);
37787 if (PyErr_Occurred()) SWIG_fail;
37788 }
37789 {
37790 resultobj = wxPyMake_wxObject(result, 0);
37791 }
37792 {
37793 if (temp1)
37794 delete arg1;
37795 }
37796 return resultobj;
37797 fail:
37798 {
37799 if (temp1)
37800 delete arg1;
37801 }
37802 return NULL;
37803 }
37804
37805
37806 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37807 PyObject *resultobj = 0;
37808 wxWindow *arg1 = (wxWindow *) 0 ;
37809 unsigned long arg2 ;
37810 wxWindow *result = 0 ;
37811 void *argp1 = 0 ;
37812 int res1 = 0 ;
37813 unsigned long val2 ;
37814 int ecode2 = 0 ;
37815 PyObject * obj0 = 0 ;
37816 PyObject * obj1 = 0 ;
37817 char * kwnames[] = {
37818 (char *) "parent",(char *) "_hWnd", NULL
37819 };
37820
37821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37823 if (!SWIG_IsOK(res1)) {
37824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37825 }
37826 arg1 = reinterpret_cast< wxWindow * >(argp1);
37827 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37828 if (!SWIG_IsOK(ecode2)) {
37829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37830 }
37831 arg2 = static_cast< unsigned long >(val2);
37832 {
37833 PyThreadState* __tstate = wxPyBeginAllowThreads();
37834 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37835 wxPyEndAllowThreads(__tstate);
37836 if (PyErr_Occurred()) SWIG_fail;
37837 }
37838 {
37839 resultobj = wxPyMake_wxObject(result, 0);
37840 }
37841 return resultobj;
37842 fail:
37843 return NULL;
37844 }
37845
37846
37847 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37848 PyObject *resultobj = 0;
37849 PyObject *result = 0 ;
37850
37851 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37852 {
37853 PyThreadState* __tstate = wxPyBeginAllowThreads();
37854 result = (PyObject *)GetTopLevelWindows();
37855 wxPyEndAllowThreads(__tstate);
37856 if (PyErr_Occurred()) SWIG_fail;
37857 }
37858 resultobj = result;
37859 return resultobj;
37860 fail:
37861 return NULL;
37862 }
37863
37864
37865 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37866 PyObject *resultobj = 0;
37867 wxValidator *result = 0 ;
37868
37869 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 result = (wxValidator *)new wxValidator();
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37884 PyObject *resultobj = 0;
37885 wxValidator *arg1 = (wxValidator *) 0 ;
37886 wxValidator *result = 0 ;
37887 void *argp1 = 0 ;
37888 int res1 = 0 ;
37889 PyObject *swig_obj[1] ;
37890
37891 if (!args) SWIG_fail;
37892 swig_obj[0] = args;
37893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37894 if (!SWIG_IsOK(res1)) {
37895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37896 }
37897 arg1 = reinterpret_cast< wxValidator * >(argp1);
37898 {
37899 PyThreadState* __tstate = wxPyBeginAllowThreads();
37900 result = (wxValidator *)(arg1)->Clone();
37901 wxPyEndAllowThreads(__tstate);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 }
37904 {
37905 resultobj = wxPyMake_wxObject(result, 0);
37906 }
37907 return resultobj;
37908 fail:
37909 return NULL;
37910 }
37911
37912
37913 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37914 PyObject *resultobj = 0;
37915 wxValidator *arg1 = (wxValidator *) 0 ;
37916 wxWindow *arg2 = (wxWindow *) 0 ;
37917 bool result;
37918 void *argp1 = 0 ;
37919 int res1 = 0 ;
37920 void *argp2 = 0 ;
37921 int res2 = 0 ;
37922 PyObject * obj0 = 0 ;
37923 PyObject * obj1 = 0 ;
37924 char * kwnames[] = {
37925 (char *) "self",(char *) "parent", NULL
37926 };
37927
37928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37930 if (!SWIG_IsOK(res1)) {
37931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37932 }
37933 arg1 = reinterpret_cast< wxValidator * >(argp1);
37934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37935 if (!SWIG_IsOK(res2)) {
37936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37937 }
37938 arg2 = reinterpret_cast< wxWindow * >(argp2);
37939 {
37940 PyThreadState* __tstate = wxPyBeginAllowThreads();
37941 result = (bool)(arg1)->Validate(arg2);
37942 wxPyEndAllowThreads(__tstate);
37943 if (PyErr_Occurred()) SWIG_fail;
37944 }
37945 {
37946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37947 }
37948 return resultobj;
37949 fail:
37950 return NULL;
37951 }
37952
37953
37954 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37955 PyObject *resultobj = 0;
37956 wxValidator *arg1 = (wxValidator *) 0 ;
37957 bool result;
37958 void *argp1 = 0 ;
37959 int res1 = 0 ;
37960 PyObject *swig_obj[1] ;
37961
37962 if (!args) SWIG_fail;
37963 swig_obj[0] = args;
37964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37965 if (!SWIG_IsOK(res1)) {
37966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37967 }
37968 arg1 = reinterpret_cast< wxValidator * >(argp1);
37969 {
37970 PyThreadState* __tstate = wxPyBeginAllowThreads();
37971 result = (bool)(arg1)->TransferToWindow();
37972 wxPyEndAllowThreads(__tstate);
37973 if (PyErr_Occurred()) SWIG_fail;
37974 }
37975 {
37976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37977 }
37978 return resultobj;
37979 fail:
37980 return NULL;
37981 }
37982
37983
37984 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37985 PyObject *resultobj = 0;
37986 wxValidator *arg1 = (wxValidator *) 0 ;
37987 bool result;
37988 void *argp1 = 0 ;
37989 int res1 = 0 ;
37990 PyObject *swig_obj[1] ;
37991
37992 if (!args) SWIG_fail;
37993 swig_obj[0] = args;
37994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37995 if (!SWIG_IsOK(res1)) {
37996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37997 }
37998 arg1 = reinterpret_cast< wxValidator * >(argp1);
37999 {
38000 PyThreadState* __tstate = wxPyBeginAllowThreads();
38001 result = (bool)(arg1)->TransferFromWindow();
38002 wxPyEndAllowThreads(__tstate);
38003 if (PyErr_Occurred()) SWIG_fail;
38004 }
38005 {
38006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38007 }
38008 return resultobj;
38009 fail:
38010 return NULL;
38011 }
38012
38013
38014 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38015 PyObject *resultobj = 0;
38016 wxValidator *arg1 = (wxValidator *) 0 ;
38017 wxWindow *result = 0 ;
38018 void *argp1 = 0 ;
38019 int res1 = 0 ;
38020 PyObject *swig_obj[1] ;
38021
38022 if (!args) SWIG_fail;
38023 swig_obj[0] = args;
38024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38025 if (!SWIG_IsOK(res1)) {
38026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38027 }
38028 arg1 = reinterpret_cast< wxValidator * >(argp1);
38029 {
38030 PyThreadState* __tstate = wxPyBeginAllowThreads();
38031 result = (wxWindow *)(arg1)->GetWindow();
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 {
38036 resultobj = wxPyMake_wxObject(result, 0);
38037 }
38038 return resultobj;
38039 fail:
38040 return NULL;
38041 }
38042
38043
38044 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38045 PyObject *resultobj = 0;
38046 wxValidator *arg1 = (wxValidator *) 0 ;
38047 wxWindow *arg2 = (wxWindow *) 0 ;
38048 void *argp1 = 0 ;
38049 int res1 = 0 ;
38050 void *argp2 = 0 ;
38051 int res2 = 0 ;
38052 PyObject * obj0 = 0 ;
38053 PyObject * obj1 = 0 ;
38054 char * kwnames[] = {
38055 (char *) "self",(char *) "window", NULL
38056 };
38057
38058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38060 if (!SWIG_IsOK(res1)) {
38061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38062 }
38063 arg1 = reinterpret_cast< wxValidator * >(argp1);
38064 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38065 if (!SWIG_IsOK(res2)) {
38066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38067 }
38068 arg2 = reinterpret_cast< wxWindow * >(argp2);
38069 {
38070 PyThreadState* __tstate = wxPyBeginAllowThreads();
38071 (arg1)->SetWindow(arg2);
38072 wxPyEndAllowThreads(__tstate);
38073 if (PyErr_Occurred()) SWIG_fail;
38074 }
38075 resultobj = SWIG_Py_Void();
38076 return resultobj;
38077 fail:
38078 return NULL;
38079 }
38080
38081
38082 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38083 PyObject *resultobj = 0;
38084 bool result;
38085
38086 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38087 {
38088 PyThreadState* __tstate = wxPyBeginAllowThreads();
38089 result = (bool)wxValidator::IsSilent();
38090 wxPyEndAllowThreads(__tstate);
38091 if (PyErr_Occurred()) SWIG_fail;
38092 }
38093 {
38094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38095 }
38096 return resultobj;
38097 fail:
38098 return NULL;
38099 }
38100
38101
38102 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38103 PyObject *resultobj = 0;
38104 int arg1 = (int) true ;
38105 int val1 ;
38106 int ecode1 = 0 ;
38107 PyObject * obj0 = 0 ;
38108 char * kwnames[] = {
38109 (char *) "doIt", NULL
38110 };
38111
38112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38113 if (obj0) {
38114 ecode1 = SWIG_AsVal_int(obj0, &val1);
38115 if (!SWIG_IsOK(ecode1)) {
38116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38117 }
38118 arg1 = static_cast< int >(val1);
38119 }
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 wxValidator::SetBellOnError(arg1);
38123 wxPyEndAllowThreads(__tstate);
38124 if (PyErr_Occurred()) SWIG_fail;
38125 }
38126 resultobj = SWIG_Py_Void();
38127 return resultobj;
38128 fail:
38129 return NULL;
38130 }
38131
38132
38133 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38134 PyObject *obj;
38135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38136 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38137 return SWIG_Py_Void();
38138 }
38139
38140 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38141 return SWIG_Python_InitShadowInstance(args);
38142 }
38143
38144 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38145 PyObject *resultobj = 0;
38146 wxPyValidator *result = 0 ;
38147
38148 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38149 {
38150 PyThreadState* __tstate = wxPyBeginAllowThreads();
38151 result = (wxPyValidator *)new wxPyValidator();
38152 wxPyEndAllowThreads(__tstate);
38153 if (PyErr_Occurred()) SWIG_fail;
38154 }
38155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38156 return resultobj;
38157 fail:
38158 return NULL;
38159 }
38160
38161
38162 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38163 PyObject *resultobj = 0;
38164 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38165 PyObject *arg2 = (PyObject *) 0 ;
38166 PyObject *arg3 = (PyObject *) 0 ;
38167 int arg4 = (int) true ;
38168 void *argp1 = 0 ;
38169 int res1 = 0 ;
38170 int val4 ;
38171 int ecode4 = 0 ;
38172 PyObject * obj0 = 0 ;
38173 PyObject * obj1 = 0 ;
38174 PyObject * obj2 = 0 ;
38175 PyObject * obj3 = 0 ;
38176 char * kwnames[] = {
38177 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38178 };
38179
38180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38182 if (!SWIG_IsOK(res1)) {
38183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38184 }
38185 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38186 arg2 = obj1;
38187 arg3 = obj2;
38188 if (obj3) {
38189 ecode4 = SWIG_AsVal_int(obj3, &val4);
38190 if (!SWIG_IsOK(ecode4)) {
38191 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38192 }
38193 arg4 = static_cast< int >(val4);
38194 }
38195 {
38196 PyThreadState* __tstate = wxPyBeginAllowThreads();
38197 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38198 wxPyEndAllowThreads(__tstate);
38199 if (PyErr_Occurred()) SWIG_fail;
38200 }
38201 resultobj = SWIG_Py_Void();
38202 return resultobj;
38203 fail:
38204 return NULL;
38205 }
38206
38207
38208 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38209 PyObject *obj;
38210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38211 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38212 return SWIG_Py_Void();
38213 }
38214
38215 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38216 return SWIG_Python_InitShadowInstance(args);
38217 }
38218
38219 SWIGINTERN int DefaultValidator_set(PyObject *) {
38220 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38221 return 1;
38222 }
38223
38224
38225 SWIGINTERN PyObject *DefaultValidator_get(void) {
38226 PyObject *pyobj = 0;
38227
38228 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38229 return pyobj;
38230 }
38231
38232
38233 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38234 PyObject *resultobj = 0;
38235 wxString const &arg1_defvalue = wxPyEmptyString ;
38236 wxString *arg1 = (wxString *) &arg1_defvalue ;
38237 long arg2 = (long) 0 ;
38238 wxMenu *result = 0 ;
38239 bool temp1 = false ;
38240 long val2 ;
38241 int ecode2 = 0 ;
38242 PyObject * obj0 = 0 ;
38243 PyObject * obj1 = 0 ;
38244 char * kwnames[] = {
38245 (char *) "title",(char *) "style", NULL
38246 };
38247
38248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38249 if (obj0) {
38250 {
38251 arg1 = wxString_in_helper(obj0);
38252 if (arg1 == NULL) SWIG_fail;
38253 temp1 = true;
38254 }
38255 }
38256 if (obj1) {
38257 ecode2 = SWIG_AsVal_long(obj1, &val2);
38258 if (!SWIG_IsOK(ecode2)) {
38259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38260 }
38261 arg2 = static_cast< long >(val2);
38262 }
38263 {
38264 if (!wxPyCheckForApp()) SWIG_fail;
38265 PyThreadState* __tstate = wxPyBeginAllowThreads();
38266 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38267 wxPyEndAllowThreads(__tstate);
38268 if (PyErr_Occurred()) SWIG_fail;
38269 }
38270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38271 {
38272 if (temp1)
38273 delete arg1;
38274 }
38275 return resultobj;
38276 fail:
38277 {
38278 if (temp1)
38279 delete arg1;
38280 }
38281 return NULL;
38282 }
38283
38284
38285 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38286 PyObject *resultobj = 0;
38287 wxMenu *arg1 = (wxMenu *) 0 ;
38288 int arg2 ;
38289 wxString *arg3 = 0 ;
38290 wxString const &arg4_defvalue = wxPyEmptyString ;
38291 wxString *arg4 = (wxString *) &arg4_defvalue ;
38292 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38293 wxMenuItem *result = 0 ;
38294 void *argp1 = 0 ;
38295 int res1 = 0 ;
38296 int val2 ;
38297 int ecode2 = 0 ;
38298 bool temp3 = false ;
38299 bool temp4 = false ;
38300 int val5 ;
38301 int ecode5 = 0 ;
38302 PyObject * obj0 = 0 ;
38303 PyObject * obj1 = 0 ;
38304 PyObject * obj2 = 0 ;
38305 PyObject * obj3 = 0 ;
38306 PyObject * obj4 = 0 ;
38307 char * kwnames[] = {
38308 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38309 };
38310
38311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38313 if (!SWIG_IsOK(res1)) {
38314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38315 }
38316 arg1 = reinterpret_cast< wxMenu * >(argp1);
38317 ecode2 = SWIG_AsVal_int(obj1, &val2);
38318 if (!SWIG_IsOK(ecode2)) {
38319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38320 }
38321 arg2 = static_cast< int >(val2);
38322 {
38323 arg3 = wxString_in_helper(obj2);
38324 if (arg3 == NULL) SWIG_fail;
38325 temp3 = true;
38326 }
38327 if (obj3) {
38328 {
38329 arg4 = wxString_in_helper(obj3);
38330 if (arg4 == NULL) SWIG_fail;
38331 temp4 = true;
38332 }
38333 }
38334 if (obj4) {
38335 ecode5 = SWIG_AsVal_int(obj4, &val5);
38336 if (!SWIG_IsOK(ecode5)) {
38337 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38338 }
38339 arg5 = static_cast< wxItemKind >(val5);
38340 }
38341 {
38342 PyThreadState* __tstate = wxPyBeginAllowThreads();
38343 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38344 wxPyEndAllowThreads(__tstate);
38345 if (PyErr_Occurred()) SWIG_fail;
38346 }
38347 {
38348 resultobj = wxPyMake_wxObject(result, (bool)0);
38349 }
38350 {
38351 if (temp3)
38352 delete arg3;
38353 }
38354 {
38355 if (temp4)
38356 delete arg4;
38357 }
38358 return resultobj;
38359 fail:
38360 {
38361 if (temp3)
38362 delete arg3;
38363 }
38364 {
38365 if (temp4)
38366 delete arg4;
38367 }
38368 return NULL;
38369 }
38370
38371
38372 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38373 PyObject *resultobj = 0;
38374 wxMenu *arg1 = (wxMenu *) 0 ;
38375 wxMenuItem *result = 0 ;
38376 void *argp1 = 0 ;
38377 int res1 = 0 ;
38378 PyObject *swig_obj[1] ;
38379
38380 if (!args) SWIG_fail;
38381 swig_obj[0] = args;
38382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38383 if (!SWIG_IsOK(res1)) {
38384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38385 }
38386 arg1 = reinterpret_cast< wxMenu * >(argp1);
38387 {
38388 PyThreadState* __tstate = wxPyBeginAllowThreads();
38389 result = (wxMenuItem *)(arg1)->AppendSeparator();
38390 wxPyEndAllowThreads(__tstate);
38391 if (PyErr_Occurred()) SWIG_fail;
38392 }
38393 {
38394 resultobj = wxPyMake_wxObject(result, (bool)0);
38395 }
38396 return resultobj;
38397 fail:
38398 return NULL;
38399 }
38400
38401
38402 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38403 PyObject *resultobj = 0;
38404 wxMenu *arg1 = (wxMenu *) 0 ;
38405 int arg2 ;
38406 wxString *arg3 = 0 ;
38407 wxString const &arg4_defvalue = wxPyEmptyString ;
38408 wxString *arg4 = (wxString *) &arg4_defvalue ;
38409 wxMenuItem *result = 0 ;
38410 void *argp1 = 0 ;
38411 int res1 = 0 ;
38412 int val2 ;
38413 int ecode2 = 0 ;
38414 bool temp3 = false ;
38415 bool temp4 = false ;
38416 PyObject * obj0 = 0 ;
38417 PyObject * obj1 = 0 ;
38418 PyObject * obj2 = 0 ;
38419 PyObject * obj3 = 0 ;
38420 char * kwnames[] = {
38421 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38422 };
38423
38424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38426 if (!SWIG_IsOK(res1)) {
38427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38428 }
38429 arg1 = reinterpret_cast< wxMenu * >(argp1);
38430 ecode2 = SWIG_AsVal_int(obj1, &val2);
38431 if (!SWIG_IsOK(ecode2)) {
38432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38433 }
38434 arg2 = static_cast< int >(val2);
38435 {
38436 arg3 = wxString_in_helper(obj2);
38437 if (arg3 == NULL) SWIG_fail;
38438 temp3 = true;
38439 }
38440 if (obj3) {
38441 {
38442 arg4 = wxString_in_helper(obj3);
38443 if (arg4 == NULL) SWIG_fail;
38444 temp4 = true;
38445 }
38446 }
38447 {
38448 PyThreadState* __tstate = wxPyBeginAllowThreads();
38449 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38450 wxPyEndAllowThreads(__tstate);
38451 if (PyErr_Occurred()) SWIG_fail;
38452 }
38453 {
38454 resultobj = wxPyMake_wxObject(result, (bool)0);
38455 }
38456 {
38457 if (temp3)
38458 delete arg3;
38459 }
38460 {
38461 if (temp4)
38462 delete arg4;
38463 }
38464 return resultobj;
38465 fail:
38466 {
38467 if (temp3)
38468 delete arg3;
38469 }
38470 {
38471 if (temp4)
38472 delete arg4;
38473 }
38474 return NULL;
38475 }
38476
38477
38478 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38479 PyObject *resultobj = 0;
38480 wxMenu *arg1 = (wxMenu *) 0 ;
38481 int arg2 ;
38482 wxString *arg3 = 0 ;
38483 wxString const &arg4_defvalue = wxPyEmptyString ;
38484 wxString *arg4 = (wxString *) &arg4_defvalue ;
38485 wxMenuItem *result = 0 ;
38486 void *argp1 = 0 ;
38487 int res1 = 0 ;
38488 int val2 ;
38489 int ecode2 = 0 ;
38490 bool temp3 = false ;
38491 bool temp4 = false ;
38492 PyObject * obj0 = 0 ;
38493 PyObject * obj1 = 0 ;
38494 PyObject * obj2 = 0 ;
38495 PyObject * obj3 = 0 ;
38496 char * kwnames[] = {
38497 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38498 };
38499
38500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38502 if (!SWIG_IsOK(res1)) {
38503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38504 }
38505 arg1 = reinterpret_cast< wxMenu * >(argp1);
38506 ecode2 = SWIG_AsVal_int(obj1, &val2);
38507 if (!SWIG_IsOK(ecode2)) {
38508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38509 }
38510 arg2 = static_cast< int >(val2);
38511 {
38512 arg3 = wxString_in_helper(obj2);
38513 if (arg3 == NULL) SWIG_fail;
38514 temp3 = true;
38515 }
38516 if (obj3) {
38517 {
38518 arg4 = wxString_in_helper(obj3);
38519 if (arg4 == NULL) SWIG_fail;
38520 temp4 = true;
38521 }
38522 }
38523 {
38524 PyThreadState* __tstate = wxPyBeginAllowThreads();
38525 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38526 wxPyEndAllowThreads(__tstate);
38527 if (PyErr_Occurred()) SWIG_fail;
38528 }
38529 {
38530 resultobj = wxPyMake_wxObject(result, (bool)0);
38531 }
38532 {
38533 if (temp3)
38534 delete arg3;
38535 }
38536 {
38537 if (temp4)
38538 delete arg4;
38539 }
38540 return resultobj;
38541 fail:
38542 {
38543 if (temp3)
38544 delete arg3;
38545 }
38546 {
38547 if (temp4)
38548 delete arg4;
38549 }
38550 return NULL;
38551 }
38552
38553
38554 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38555 PyObject *resultobj = 0;
38556 wxMenu *arg1 = (wxMenu *) 0 ;
38557 int arg2 ;
38558 wxString *arg3 = 0 ;
38559 wxMenu *arg4 = (wxMenu *) 0 ;
38560 wxString const &arg5_defvalue = wxPyEmptyString ;
38561 wxString *arg5 = (wxString *) &arg5_defvalue ;
38562 wxMenuItem *result = 0 ;
38563 void *argp1 = 0 ;
38564 int res1 = 0 ;
38565 int val2 ;
38566 int ecode2 = 0 ;
38567 bool temp3 = false ;
38568 void *argp4 = 0 ;
38569 int res4 = 0 ;
38570 bool temp5 = false ;
38571 PyObject * obj0 = 0 ;
38572 PyObject * obj1 = 0 ;
38573 PyObject * obj2 = 0 ;
38574 PyObject * obj3 = 0 ;
38575 PyObject * obj4 = 0 ;
38576 char * kwnames[] = {
38577 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38578 };
38579
38580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38582 if (!SWIG_IsOK(res1)) {
38583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38584 }
38585 arg1 = reinterpret_cast< wxMenu * >(argp1);
38586 ecode2 = SWIG_AsVal_int(obj1, &val2);
38587 if (!SWIG_IsOK(ecode2)) {
38588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38589 }
38590 arg2 = static_cast< int >(val2);
38591 {
38592 arg3 = wxString_in_helper(obj2);
38593 if (arg3 == NULL) SWIG_fail;
38594 temp3 = true;
38595 }
38596 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38597 if (!SWIG_IsOK(res4)) {
38598 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38599 }
38600 arg4 = reinterpret_cast< wxMenu * >(argp4);
38601 if (obj4) {
38602 {
38603 arg5 = wxString_in_helper(obj4);
38604 if (arg5 == NULL) SWIG_fail;
38605 temp5 = true;
38606 }
38607 }
38608 {
38609 PyThreadState* __tstate = wxPyBeginAllowThreads();
38610 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38611 wxPyEndAllowThreads(__tstate);
38612 if (PyErr_Occurred()) SWIG_fail;
38613 }
38614 {
38615 resultobj = wxPyMake_wxObject(result, (bool)0);
38616 }
38617 {
38618 if (temp3)
38619 delete arg3;
38620 }
38621 {
38622 if (temp5)
38623 delete arg5;
38624 }
38625 return resultobj;
38626 fail:
38627 {
38628 if (temp3)
38629 delete arg3;
38630 }
38631 {
38632 if (temp5)
38633 delete arg5;
38634 }
38635 return NULL;
38636 }
38637
38638
38639 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38640 PyObject *resultobj = 0;
38641 wxMenu *arg1 = (wxMenu *) 0 ;
38642 wxMenu *arg2 = (wxMenu *) 0 ;
38643 wxString *arg3 = 0 ;
38644 wxString const &arg4_defvalue = wxPyEmptyString ;
38645 wxString *arg4 = (wxString *) &arg4_defvalue ;
38646 wxMenuItem *result = 0 ;
38647 void *argp1 = 0 ;
38648 int res1 = 0 ;
38649 void *argp2 = 0 ;
38650 int res2 = 0 ;
38651 bool temp3 = false ;
38652 bool temp4 = false ;
38653 PyObject * obj0 = 0 ;
38654 PyObject * obj1 = 0 ;
38655 PyObject * obj2 = 0 ;
38656 PyObject * obj3 = 0 ;
38657 char * kwnames[] = {
38658 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38659 };
38660
38661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38663 if (!SWIG_IsOK(res1)) {
38664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38665 }
38666 arg1 = reinterpret_cast< wxMenu * >(argp1);
38667 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38668 if (!SWIG_IsOK(res2)) {
38669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38670 }
38671 arg2 = reinterpret_cast< wxMenu * >(argp2);
38672 {
38673 arg3 = wxString_in_helper(obj2);
38674 if (arg3 == NULL) SWIG_fail;
38675 temp3 = true;
38676 }
38677 if (obj3) {
38678 {
38679 arg4 = wxString_in_helper(obj3);
38680 if (arg4 == NULL) SWIG_fail;
38681 temp4 = true;
38682 }
38683 }
38684 {
38685 PyThreadState* __tstate = wxPyBeginAllowThreads();
38686 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38687 wxPyEndAllowThreads(__tstate);
38688 if (PyErr_Occurred()) SWIG_fail;
38689 }
38690 {
38691 resultobj = wxPyMake_wxObject(result, (bool)0);
38692 }
38693 {
38694 if (temp3)
38695 delete arg3;
38696 }
38697 {
38698 if (temp4)
38699 delete arg4;
38700 }
38701 return resultobj;
38702 fail:
38703 {
38704 if (temp3)
38705 delete arg3;
38706 }
38707 {
38708 if (temp4)
38709 delete arg4;
38710 }
38711 return NULL;
38712 }
38713
38714
38715 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38716 PyObject *resultobj = 0;
38717 wxMenu *arg1 = (wxMenu *) 0 ;
38718 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38719 wxMenuItem *result = 0 ;
38720 void *argp1 = 0 ;
38721 int res1 = 0 ;
38722 int res2 = 0 ;
38723 PyObject * obj0 = 0 ;
38724 PyObject * obj1 = 0 ;
38725 char * kwnames[] = {
38726 (char *) "self",(char *) "item", NULL
38727 };
38728
38729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38731 if (!SWIG_IsOK(res1)) {
38732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38733 }
38734 arg1 = reinterpret_cast< wxMenu * >(argp1);
38735 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38736 if (!SWIG_IsOK(res2)) {
38737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38738 }
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 result = (wxMenuItem *)(arg1)->Append(arg2);
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 {
38746 resultobj = wxPyMake_wxObject(result, (bool)0);
38747 }
38748 return resultobj;
38749 fail:
38750 return NULL;
38751 }
38752
38753
38754 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38755 PyObject *resultobj = 0;
38756 wxMenu *arg1 = (wxMenu *) 0 ;
38757 size_t arg2 ;
38758 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38759 wxMenuItem *result = 0 ;
38760 void *argp1 = 0 ;
38761 int res1 = 0 ;
38762 size_t val2 ;
38763 int ecode2 = 0 ;
38764 int res3 = 0 ;
38765 PyObject * obj0 = 0 ;
38766 PyObject * obj1 = 0 ;
38767 PyObject * obj2 = 0 ;
38768 char * kwnames[] = {
38769 (char *) "self",(char *) "pos",(char *) "item", NULL
38770 };
38771
38772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38774 if (!SWIG_IsOK(res1)) {
38775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38776 }
38777 arg1 = reinterpret_cast< wxMenu * >(argp1);
38778 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38779 if (!SWIG_IsOK(ecode2)) {
38780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38781 }
38782 arg2 = static_cast< size_t >(val2);
38783 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38784 if (!SWIG_IsOK(res3)) {
38785 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38786 }
38787 {
38788 PyThreadState* __tstate = wxPyBeginAllowThreads();
38789 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38790 wxPyEndAllowThreads(__tstate);
38791 if (PyErr_Occurred()) SWIG_fail;
38792 }
38793 {
38794 resultobj = wxPyMake_wxObject(result, (bool)0);
38795 }
38796 return resultobj;
38797 fail:
38798 return NULL;
38799 }
38800
38801
38802 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38803 PyObject *resultobj = 0;
38804 wxMenu *arg1 = (wxMenu *) 0 ;
38805 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38806 wxMenuItem *result = 0 ;
38807 void *argp1 = 0 ;
38808 int res1 = 0 ;
38809 int res2 = 0 ;
38810 PyObject * obj0 = 0 ;
38811 PyObject * obj1 = 0 ;
38812 char * kwnames[] = {
38813 (char *) "self",(char *) "item", NULL
38814 };
38815
38816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38818 if (!SWIG_IsOK(res1)) {
38819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38820 }
38821 arg1 = reinterpret_cast< wxMenu * >(argp1);
38822 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38823 if (!SWIG_IsOK(res2)) {
38824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38825 }
38826 {
38827 PyThreadState* __tstate = wxPyBeginAllowThreads();
38828 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38829 wxPyEndAllowThreads(__tstate);
38830 if (PyErr_Occurred()) SWIG_fail;
38831 }
38832 {
38833 resultobj = wxPyMake_wxObject(result, (bool)0);
38834 }
38835 return resultobj;
38836 fail:
38837 return NULL;
38838 }
38839
38840
38841 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38842 PyObject *resultobj = 0;
38843 wxMenu *arg1 = (wxMenu *) 0 ;
38844 void *argp1 = 0 ;
38845 int res1 = 0 ;
38846 PyObject *swig_obj[1] ;
38847
38848 if (!args) SWIG_fail;
38849 swig_obj[0] = args;
38850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38851 if (!SWIG_IsOK(res1)) {
38852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38853 }
38854 arg1 = reinterpret_cast< wxMenu * >(argp1);
38855 {
38856 PyThreadState* __tstate = wxPyBeginAllowThreads();
38857 (arg1)->Break();
38858 wxPyEndAllowThreads(__tstate);
38859 if (PyErr_Occurred()) SWIG_fail;
38860 }
38861 resultobj = SWIG_Py_Void();
38862 return resultobj;
38863 fail:
38864 return NULL;
38865 }
38866
38867
38868 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38869 PyObject *resultobj = 0;
38870 wxMenu *arg1 = (wxMenu *) 0 ;
38871 size_t arg2 ;
38872 int arg3 ;
38873 wxString *arg4 = 0 ;
38874 wxString const &arg5_defvalue = wxPyEmptyString ;
38875 wxString *arg5 = (wxString *) &arg5_defvalue ;
38876 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38877 wxMenuItem *result = 0 ;
38878 void *argp1 = 0 ;
38879 int res1 = 0 ;
38880 size_t val2 ;
38881 int ecode2 = 0 ;
38882 int val3 ;
38883 int ecode3 = 0 ;
38884 bool temp4 = false ;
38885 bool temp5 = false ;
38886 int val6 ;
38887 int ecode6 = 0 ;
38888 PyObject * obj0 = 0 ;
38889 PyObject * obj1 = 0 ;
38890 PyObject * obj2 = 0 ;
38891 PyObject * obj3 = 0 ;
38892 PyObject * obj4 = 0 ;
38893 PyObject * obj5 = 0 ;
38894 char * kwnames[] = {
38895 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38896 };
38897
38898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38900 if (!SWIG_IsOK(res1)) {
38901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38902 }
38903 arg1 = reinterpret_cast< wxMenu * >(argp1);
38904 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38905 if (!SWIG_IsOK(ecode2)) {
38906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38907 }
38908 arg2 = static_cast< size_t >(val2);
38909 ecode3 = SWIG_AsVal_int(obj2, &val3);
38910 if (!SWIG_IsOK(ecode3)) {
38911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38912 }
38913 arg3 = static_cast< int >(val3);
38914 {
38915 arg4 = wxString_in_helper(obj3);
38916 if (arg4 == NULL) SWIG_fail;
38917 temp4 = true;
38918 }
38919 if (obj4) {
38920 {
38921 arg5 = wxString_in_helper(obj4);
38922 if (arg5 == NULL) SWIG_fail;
38923 temp5 = true;
38924 }
38925 }
38926 if (obj5) {
38927 ecode6 = SWIG_AsVal_int(obj5, &val6);
38928 if (!SWIG_IsOK(ecode6)) {
38929 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38930 }
38931 arg6 = static_cast< wxItemKind >(val6);
38932 }
38933 {
38934 PyThreadState* __tstate = wxPyBeginAllowThreads();
38935 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38936 wxPyEndAllowThreads(__tstate);
38937 if (PyErr_Occurred()) SWIG_fail;
38938 }
38939 {
38940 resultobj = wxPyMake_wxObject(result, (bool)0);
38941 }
38942 {
38943 if (temp4)
38944 delete arg4;
38945 }
38946 {
38947 if (temp5)
38948 delete arg5;
38949 }
38950 return resultobj;
38951 fail:
38952 {
38953 if (temp4)
38954 delete arg4;
38955 }
38956 {
38957 if (temp5)
38958 delete arg5;
38959 }
38960 return NULL;
38961 }
38962
38963
38964 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38965 PyObject *resultobj = 0;
38966 wxMenu *arg1 = (wxMenu *) 0 ;
38967 size_t arg2 ;
38968 wxMenuItem *result = 0 ;
38969 void *argp1 = 0 ;
38970 int res1 = 0 ;
38971 size_t val2 ;
38972 int ecode2 = 0 ;
38973 PyObject * obj0 = 0 ;
38974 PyObject * obj1 = 0 ;
38975 char * kwnames[] = {
38976 (char *) "self",(char *) "pos", NULL
38977 };
38978
38979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38981 if (!SWIG_IsOK(res1)) {
38982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38983 }
38984 arg1 = reinterpret_cast< wxMenu * >(argp1);
38985 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38986 if (!SWIG_IsOK(ecode2)) {
38987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38988 }
38989 arg2 = static_cast< size_t >(val2);
38990 {
38991 PyThreadState* __tstate = wxPyBeginAllowThreads();
38992 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38993 wxPyEndAllowThreads(__tstate);
38994 if (PyErr_Occurred()) SWIG_fail;
38995 }
38996 {
38997 resultobj = wxPyMake_wxObject(result, (bool)0);
38998 }
38999 return resultobj;
39000 fail:
39001 return NULL;
39002 }
39003
39004
39005 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39006 PyObject *resultobj = 0;
39007 wxMenu *arg1 = (wxMenu *) 0 ;
39008 size_t arg2 ;
39009 int arg3 ;
39010 wxString *arg4 = 0 ;
39011 wxString const &arg5_defvalue = wxPyEmptyString ;
39012 wxString *arg5 = (wxString *) &arg5_defvalue ;
39013 wxMenuItem *result = 0 ;
39014 void *argp1 = 0 ;
39015 int res1 = 0 ;
39016 size_t val2 ;
39017 int ecode2 = 0 ;
39018 int val3 ;
39019 int ecode3 = 0 ;
39020 bool temp4 = false ;
39021 bool temp5 = false ;
39022 PyObject * obj0 = 0 ;
39023 PyObject * obj1 = 0 ;
39024 PyObject * obj2 = 0 ;
39025 PyObject * obj3 = 0 ;
39026 PyObject * obj4 = 0 ;
39027 char * kwnames[] = {
39028 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39029 };
39030
39031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39033 if (!SWIG_IsOK(res1)) {
39034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39035 }
39036 arg1 = reinterpret_cast< wxMenu * >(argp1);
39037 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39038 if (!SWIG_IsOK(ecode2)) {
39039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39040 }
39041 arg2 = static_cast< size_t >(val2);
39042 ecode3 = SWIG_AsVal_int(obj2, &val3);
39043 if (!SWIG_IsOK(ecode3)) {
39044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39045 }
39046 arg3 = static_cast< int >(val3);
39047 {
39048 arg4 = wxString_in_helper(obj3);
39049 if (arg4 == NULL) SWIG_fail;
39050 temp4 = true;
39051 }
39052 if (obj4) {
39053 {
39054 arg5 = wxString_in_helper(obj4);
39055 if (arg5 == NULL) SWIG_fail;
39056 temp5 = true;
39057 }
39058 }
39059 {
39060 PyThreadState* __tstate = wxPyBeginAllowThreads();
39061 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39062 wxPyEndAllowThreads(__tstate);
39063 if (PyErr_Occurred()) SWIG_fail;
39064 }
39065 {
39066 resultobj = wxPyMake_wxObject(result, (bool)0);
39067 }
39068 {
39069 if (temp4)
39070 delete arg4;
39071 }
39072 {
39073 if (temp5)
39074 delete arg5;
39075 }
39076 return resultobj;
39077 fail:
39078 {
39079 if (temp4)
39080 delete arg4;
39081 }
39082 {
39083 if (temp5)
39084 delete arg5;
39085 }
39086 return NULL;
39087 }
39088
39089
39090 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39091 PyObject *resultobj = 0;
39092 wxMenu *arg1 = (wxMenu *) 0 ;
39093 size_t arg2 ;
39094 int arg3 ;
39095 wxString *arg4 = 0 ;
39096 wxString const &arg5_defvalue = wxPyEmptyString ;
39097 wxString *arg5 = (wxString *) &arg5_defvalue ;
39098 wxMenuItem *result = 0 ;
39099 void *argp1 = 0 ;
39100 int res1 = 0 ;
39101 size_t val2 ;
39102 int ecode2 = 0 ;
39103 int val3 ;
39104 int ecode3 = 0 ;
39105 bool temp4 = false ;
39106 bool temp5 = false ;
39107 PyObject * obj0 = 0 ;
39108 PyObject * obj1 = 0 ;
39109 PyObject * obj2 = 0 ;
39110 PyObject * obj3 = 0 ;
39111 PyObject * obj4 = 0 ;
39112 char * kwnames[] = {
39113 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39114 };
39115
39116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39118 if (!SWIG_IsOK(res1)) {
39119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39120 }
39121 arg1 = reinterpret_cast< wxMenu * >(argp1);
39122 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39123 if (!SWIG_IsOK(ecode2)) {
39124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39125 }
39126 arg2 = static_cast< size_t >(val2);
39127 ecode3 = SWIG_AsVal_int(obj2, &val3);
39128 if (!SWIG_IsOK(ecode3)) {
39129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39130 }
39131 arg3 = static_cast< int >(val3);
39132 {
39133 arg4 = wxString_in_helper(obj3);
39134 if (arg4 == NULL) SWIG_fail;
39135 temp4 = true;
39136 }
39137 if (obj4) {
39138 {
39139 arg5 = wxString_in_helper(obj4);
39140 if (arg5 == NULL) SWIG_fail;
39141 temp5 = true;
39142 }
39143 }
39144 {
39145 PyThreadState* __tstate = wxPyBeginAllowThreads();
39146 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39147 wxPyEndAllowThreads(__tstate);
39148 if (PyErr_Occurred()) SWIG_fail;
39149 }
39150 {
39151 resultobj = wxPyMake_wxObject(result, (bool)0);
39152 }
39153 {
39154 if (temp4)
39155 delete arg4;
39156 }
39157 {
39158 if (temp5)
39159 delete arg5;
39160 }
39161 return resultobj;
39162 fail:
39163 {
39164 if (temp4)
39165 delete arg4;
39166 }
39167 {
39168 if (temp5)
39169 delete arg5;
39170 }
39171 return NULL;
39172 }
39173
39174
39175 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39176 PyObject *resultobj = 0;
39177 wxMenu *arg1 = (wxMenu *) 0 ;
39178 size_t arg2 ;
39179 int arg3 ;
39180 wxString *arg4 = 0 ;
39181 wxMenu *arg5 = (wxMenu *) 0 ;
39182 wxString const &arg6_defvalue = wxPyEmptyString ;
39183 wxString *arg6 = (wxString *) &arg6_defvalue ;
39184 wxMenuItem *result = 0 ;
39185 void *argp1 = 0 ;
39186 int res1 = 0 ;
39187 size_t val2 ;
39188 int ecode2 = 0 ;
39189 int val3 ;
39190 int ecode3 = 0 ;
39191 bool temp4 = false ;
39192 void *argp5 = 0 ;
39193 int res5 = 0 ;
39194 bool temp6 = false ;
39195 PyObject * obj0 = 0 ;
39196 PyObject * obj1 = 0 ;
39197 PyObject * obj2 = 0 ;
39198 PyObject * obj3 = 0 ;
39199 PyObject * obj4 = 0 ;
39200 PyObject * obj5 = 0 ;
39201 char * kwnames[] = {
39202 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39203 };
39204
39205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39207 if (!SWIG_IsOK(res1)) {
39208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39209 }
39210 arg1 = reinterpret_cast< wxMenu * >(argp1);
39211 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39212 if (!SWIG_IsOK(ecode2)) {
39213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39214 }
39215 arg2 = static_cast< size_t >(val2);
39216 ecode3 = SWIG_AsVal_int(obj2, &val3);
39217 if (!SWIG_IsOK(ecode3)) {
39218 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39219 }
39220 arg3 = static_cast< int >(val3);
39221 {
39222 arg4 = wxString_in_helper(obj3);
39223 if (arg4 == NULL) SWIG_fail;
39224 temp4 = true;
39225 }
39226 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39227 if (!SWIG_IsOK(res5)) {
39228 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39229 }
39230 arg5 = reinterpret_cast< wxMenu * >(argp5);
39231 if (obj5) {
39232 {
39233 arg6 = wxString_in_helper(obj5);
39234 if (arg6 == NULL) SWIG_fail;
39235 temp6 = true;
39236 }
39237 }
39238 {
39239 PyThreadState* __tstate = wxPyBeginAllowThreads();
39240 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39241 wxPyEndAllowThreads(__tstate);
39242 if (PyErr_Occurred()) SWIG_fail;
39243 }
39244 {
39245 resultobj = wxPyMake_wxObject(result, (bool)0);
39246 }
39247 {
39248 if (temp4)
39249 delete arg4;
39250 }
39251 {
39252 if (temp6)
39253 delete arg6;
39254 }
39255 return resultobj;
39256 fail:
39257 {
39258 if (temp4)
39259 delete arg4;
39260 }
39261 {
39262 if (temp6)
39263 delete arg6;
39264 }
39265 return NULL;
39266 }
39267
39268
39269 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj = 0;
39271 wxMenu *arg1 = (wxMenu *) 0 ;
39272 int arg2 ;
39273 wxString *arg3 = 0 ;
39274 wxString const &arg4_defvalue = wxPyEmptyString ;
39275 wxString *arg4 = (wxString *) &arg4_defvalue ;
39276 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39277 wxMenuItem *result = 0 ;
39278 void *argp1 = 0 ;
39279 int res1 = 0 ;
39280 int val2 ;
39281 int ecode2 = 0 ;
39282 bool temp3 = false ;
39283 bool temp4 = false ;
39284 int val5 ;
39285 int ecode5 = 0 ;
39286 PyObject * obj0 = 0 ;
39287 PyObject * obj1 = 0 ;
39288 PyObject * obj2 = 0 ;
39289 PyObject * obj3 = 0 ;
39290 PyObject * obj4 = 0 ;
39291 char * kwnames[] = {
39292 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39293 };
39294
39295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39297 if (!SWIG_IsOK(res1)) {
39298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39299 }
39300 arg1 = reinterpret_cast< wxMenu * >(argp1);
39301 ecode2 = SWIG_AsVal_int(obj1, &val2);
39302 if (!SWIG_IsOK(ecode2)) {
39303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39304 }
39305 arg2 = static_cast< int >(val2);
39306 {
39307 arg3 = wxString_in_helper(obj2);
39308 if (arg3 == NULL) SWIG_fail;
39309 temp3 = true;
39310 }
39311 if (obj3) {
39312 {
39313 arg4 = wxString_in_helper(obj3);
39314 if (arg4 == NULL) SWIG_fail;
39315 temp4 = true;
39316 }
39317 }
39318 if (obj4) {
39319 ecode5 = SWIG_AsVal_int(obj4, &val5);
39320 if (!SWIG_IsOK(ecode5)) {
39321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39322 }
39323 arg5 = static_cast< wxItemKind >(val5);
39324 }
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39328 wxPyEndAllowThreads(__tstate);
39329 if (PyErr_Occurred()) SWIG_fail;
39330 }
39331 {
39332 resultobj = wxPyMake_wxObject(result, (bool)0);
39333 }
39334 {
39335 if (temp3)
39336 delete arg3;
39337 }
39338 {
39339 if (temp4)
39340 delete arg4;
39341 }
39342 return resultobj;
39343 fail:
39344 {
39345 if (temp3)
39346 delete arg3;
39347 }
39348 {
39349 if (temp4)
39350 delete arg4;
39351 }
39352 return NULL;
39353 }
39354
39355
39356 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39357 PyObject *resultobj = 0;
39358 wxMenu *arg1 = (wxMenu *) 0 ;
39359 wxMenuItem *result = 0 ;
39360 void *argp1 = 0 ;
39361 int res1 = 0 ;
39362 PyObject *swig_obj[1] ;
39363
39364 if (!args) SWIG_fail;
39365 swig_obj[0] = args;
39366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39367 if (!SWIG_IsOK(res1)) {
39368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39369 }
39370 arg1 = reinterpret_cast< wxMenu * >(argp1);
39371 {
39372 PyThreadState* __tstate = wxPyBeginAllowThreads();
39373 result = (wxMenuItem *)(arg1)->PrependSeparator();
39374 wxPyEndAllowThreads(__tstate);
39375 if (PyErr_Occurred()) SWIG_fail;
39376 }
39377 {
39378 resultobj = wxPyMake_wxObject(result, (bool)0);
39379 }
39380 return resultobj;
39381 fail:
39382 return NULL;
39383 }
39384
39385
39386 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39387 PyObject *resultobj = 0;
39388 wxMenu *arg1 = (wxMenu *) 0 ;
39389 int arg2 ;
39390 wxString *arg3 = 0 ;
39391 wxString const &arg4_defvalue = wxPyEmptyString ;
39392 wxString *arg4 = (wxString *) &arg4_defvalue ;
39393 wxMenuItem *result = 0 ;
39394 void *argp1 = 0 ;
39395 int res1 = 0 ;
39396 int val2 ;
39397 int ecode2 = 0 ;
39398 bool temp3 = false ;
39399 bool temp4 = false ;
39400 PyObject * obj0 = 0 ;
39401 PyObject * obj1 = 0 ;
39402 PyObject * obj2 = 0 ;
39403 PyObject * obj3 = 0 ;
39404 char * kwnames[] = {
39405 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39406 };
39407
39408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39410 if (!SWIG_IsOK(res1)) {
39411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39412 }
39413 arg1 = reinterpret_cast< wxMenu * >(argp1);
39414 ecode2 = SWIG_AsVal_int(obj1, &val2);
39415 if (!SWIG_IsOK(ecode2)) {
39416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39417 }
39418 arg2 = static_cast< int >(val2);
39419 {
39420 arg3 = wxString_in_helper(obj2);
39421 if (arg3 == NULL) SWIG_fail;
39422 temp3 = true;
39423 }
39424 if (obj3) {
39425 {
39426 arg4 = wxString_in_helper(obj3);
39427 if (arg4 == NULL) SWIG_fail;
39428 temp4 = true;
39429 }
39430 }
39431 {
39432 PyThreadState* __tstate = wxPyBeginAllowThreads();
39433 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39434 wxPyEndAllowThreads(__tstate);
39435 if (PyErr_Occurred()) SWIG_fail;
39436 }
39437 {
39438 resultobj = wxPyMake_wxObject(result, (bool)0);
39439 }
39440 {
39441 if (temp3)
39442 delete arg3;
39443 }
39444 {
39445 if (temp4)
39446 delete arg4;
39447 }
39448 return resultobj;
39449 fail:
39450 {
39451 if (temp3)
39452 delete arg3;
39453 }
39454 {
39455 if (temp4)
39456 delete arg4;
39457 }
39458 return NULL;
39459 }
39460
39461
39462 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39463 PyObject *resultobj = 0;
39464 wxMenu *arg1 = (wxMenu *) 0 ;
39465 int arg2 ;
39466 wxString *arg3 = 0 ;
39467 wxString const &arg4_defvalue = wxPyEmptyString ;
39468 wxString *arg4 = (wxString *) &arg4_defvalue ;
39469 wxMenuItem *result = 0 ;
39470 void *argp1 = 0 ;
39471 int res1 = 0 ;
39472 int val2 ;
39473 int ecode2 = 0 ;
39474 bool temp3 = false ;
39475 bool temp4 = false ;
39476 PyObject * obj0 = 0 ;
39477 PyObject * obj1 = 0 ;
39478 PyObject * obj2 = 0 ;
39479 PyObject * obj3 = 0 ;
39480 char * kwnames[] = {
39481 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39482 };
39483
39484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39486 if (!SWIG_IsOK(res1)) {
39487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39488 }
39489 arg1 = reinterpret_cast< wxMenu * >(argp1);
39490 ecode2 = SWIG_AsVal_int(obj1, &val2);
39491 if (!SWIG_IsOK(ecode2)) {
39492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39493 }
39494 arg2 = static_cast< int >(val2);
39495 {
39496 arg3 = wxString_in_helper(obj2);
39497 if (arg3 == NULL) SWIG_fail;
39498 temp3 = true;
39499 }
39500 if (obj3) {
39501 {
39502 arg4 = wxString_in_helper(obj3);
39503 if (arg4 == NULL) SWIG_fail;
39504 temp4 = true;
39505 }
39506 }
39507 {
39508 PyThreadState* __tstate = wxPyBeginAllowThreads();
39509 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39510 wxPyEndAllowThreads(__tstate);
39511 if (PyErr_Occurred()) SWIG_fail;
39512 }
39513 {
39514 resultobj = wxPyMake_wxObject(result, (bool)0);
39515 }
39516 {
39517 if (temp3)
39518 delete arg3;
39519 }
39520 {
39521 if (temp4)
39522 delete arg4;
39523 }
39524 return resultobj;
39525 fail:
39526 {
39527 if (temp3)
39528 delete arg3;
39529 }
39530 {
39531 if (temp4)
39532 delete arg4;
39533 }
39534 return NULL;
39535 }
39536
39537
39538 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39539 PyObject *resultobj = 0;
39540 wxMenu *arg1 = (wxMenu *) 0 ;
39541 int arg2 ;
39542 wxString *arg3 = 0 ;
39543 wxMenu *arg4 = (wxMenu *) 0 ;
39544 wxString const &arg5_defvalue = wxPyEmptyString ;
39545 wxString *arg5 = (wxString *) &arg5_defvalue ;
39546 wxMenuItem *result = 0 ;
39547 void *argp1 = 0 ;
39548 int res1 = 0 ;
39549 int val2 ;
39550 int ecode2 = 0 ;
39551 bool temp3 = false ;
39552 void *argp4 = 0 ;
39553 int res4 = 0 ;
39554 bool temp5 = false ;
39555 PyObject * obj0 = 0 ;
39556 PyObject * obj1 = 0 ;
39557 PyObject * obj2 = 0 ;
39558 PyObject * obj3 = 0 ;
39559 PyObject * obj4 = 0 ;
39560 char * kwnames[] = {
39561 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39562 };
39563
39564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39566 if (!SWIG_IsOK(res1)) {
39567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39568 }
39569 arg1 = reinterpret_cast< wxMenu * >(argp1);
39570 ecode2 = SWIG_AsVal_int(obj1, &val2);
39571 if (!SWIG_IsOK(ecode2)) {
39572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39573 }
39574 arg2 = static_cast< int >(val2);
39575 {
39576 arg3 = wxString_in_helper(obj2);
39577 if (arg3 == NULL) SWIG_fail;
39578 temp3 = true;
39579 }
39580 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39581 if (!SWIG_IsOK(res4)) {
39582 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39583 }
39584 arg4 = reinterpret_cast< wxMenu * >(argp4);
39585 if (obj4) {
39586 {
39587 arg5 = wxString_in_helper(obj4);
39588 if (arg5 == NULL) SWIG_fail;
39589 temp5 = true;
39590 }
39591 }
39592 {
39593 PyThreadState* __tstate = wxPyBeginAllowThreads();
39594 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39595 wxPyEndAllowThreads(__tstate);
39596 if (PyErr_Occurred()) SWIG_fail;
39597 }
39598 {
39599 resultobj = wxPyMake_wxObject(result, (bool)0);
39600 }
39601 {
39602 if (temp3)
39603 delete arg3;
39604 }
39605 {
39606 if (temp5)
39607 delete arg5;
39608 }
39609 return resultobj;
39610 fail:
39611 {
39612 if (temp3)
39613 delete arg3;
39614 }
39615 {
39616 if (temp5)
39617 delete arg5;
39618 }
39619 return NULL;
39620 }
39621
39622
39623 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39624 PyObject *resultobj = 0;
39625 wxMenu *arg1 = (wxMenu *) 0 ;
39626 int arg2 ;
39627 wxMenuItem *result = 0 ;
39628 void *argp1 = 0 ;
39629 int res1 = 0 ;
39630 int val2 ;
39631 int ecode2 = 0 ;
39632 PyObject * obj0 = 0 ;
39633 PyObject * obj1 = 0 ;
39634 char * kwnames[] = {
39635 (char *) "self",(char *) "id", NULL
39636 };
39637
39638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39640 if (!SWIG_IsOK(res1)) {
39641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39642 }
39643 arg1 = reinterpret_cast< wxMenu * >(argp1);
39644 ecode2 = SWIG_AsVal_int(obj1, &val2);
39645 if (!SWIG_IsOK(ecode2)) {
39646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39647 }
39648 arg2 = static_cast< int >(val2);
39649 {
39650 PyThreadState* __tstate = wxPyBeginAllowThreads();
39651 result = (wxMenuItem *)(arg1)->Remove(arg2);
39652 wxPyEndAllowThreads(__tstate);
39653 if (PyErr_Occurred()) SWIG_fail;
39654 }
39655 {
39656 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39657 }
39658 return resultobj;
39659 fail:
39660 return NULL;
39661 }
39662
39663
39664 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39665 PyObject *resultobj = 0;
39666 wxMenu *arg1 = (wxMenu *) 0 ;
39667 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39668 wxMenuItem *result = 0 ;
39669 void *argp1 = 0 ;
39670 int res1 = 0 ;
39671 void *argp2 = 0 ;
39672 int res2 = 0 ;
39673 PyObject * obj0 = 0 ;
39674 PyObject * obj1 = 0 ;
39675 char * kwnames[] = {
39676 (char *) "self",(char *) "item", NULL
39677 };
39678
39679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39681 if (!SWIG_IsOK(res1)) {
39682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39683 }
39684 arg1 = reinterpret_cast< wxMenu * >(argp1);
39685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39686 if (!SWIG_IsOK(res2)) {
39687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39688 }
39689 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39690 {
39691 PyThreadState* __tstate = wxPyBeginAllowThreads();
39692 result = (wxMenuItem *)(arg1)->Remove(arg2);
39693 wxPyEndAllowThreads(__tstate);
39694 if (PyErr_Occurred()) SWIG_fail;
39695 }
39696 {
39697 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39698 }
39699 return resultobj;
39700 fail:
39701 return NULL;
39702 }
39703
39704
39705 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39706 PyObject *resultobj = 0;
39707 wxMenu *arg1 = (wxMenu *) 0 ;
39708 int arg2 ;
39709 bool result;
39710 void *argp1 = 0 ;
39711 int res1 = 0 ;
39712 int val2 ;
39713 int ecode2 = 0 ;
39714 PyObject * obj0 = 0 ;
39715 PyObject * obj1 = 0 ;
39716 char * kwnames[] = {
39717 (char *) "self",(char *) "id", NULL
39718 };
39719
39720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39722 if (!SWIG_IsOK(res1)) {
39723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39724 }
39725 arg1 = reinterpret_cast< wxMenu * >(argp1);
39726 ecode2 = SWIG_AsVal_int(obj1, &val2);
39727 if (!SWIG_IsOK(ecode2)) {
39728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39729 }
39730 arg2 = static_cast< int >(val2);
39731 {
39732 PyThreadState* __tstate = wxPyBeginAllowThreads();
39733 result = (bool)(arg1)->Delete(arg2);
39734 wxPyEndAllowThreads(__tstate);
39735 if (PyErr_Occurred()) SWIG_fail;
39736 }
39737 {
39738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39739 }
39740 return resultobj;
39741 fail:
39742 return NULL;
39743 }
39744
39745
39746 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39747 PyObject *resultobj = 0;
39748 wxMenu *arg1 = (wxMenu *) 0 ;
39749 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39750 bool result;
39751 void *argp1 = 0 ;
39752 int res1 = 0 ;
39753 void *argp2 = 0 ;
39754 int res2 = 0 ;
39755 PyObject * obj0 = 0 ;
39756 PyObject * obj1 = 0 ;
39757 char * kwnames[] = {
39758 (char *) "self",(char *) "item", NULL
39759 };
39760
39761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39763 if (!SWIG_IsOK(res1)) {
39764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39765 }
39766 arg1 = reinterpret_cast< wxMenu * >(argp1);
39767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39768 if (!SWIG_IsOK(res2)) {
39769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39770 }
39771 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39772 {
39773 PyThreadState* __tstate = wxPyBeginAllowThreads();
39774 result = (bool)(arg1)->Delete(arg2);
39775 wxPyEndAllowThreads(__tstate);
39776 if (PyErr_Occurred()) SWIG_fail;
39777 }
39778 {
39779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39780 }
39781 return resultobj;
39782 fail:
39783 return NULL;
39784 }
39785
39786
39787 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39788 PyObject *resultobj = 0;
39789 wxMenu *arg1 = (wxMenu *) 0 ;
39790 void *argp1 = 0 ;
39791 int res1 = 0 ;
39792 PyObject *swig_obj[1] ;
39793
39794 if (!args) SWIG_fail;
39795 swig_obj[0] = args;
39796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39797 if (!SWIG_IsOK(res1)) {
39798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39799 }
39800 arg1 = reinterpret_cast< wxMenu * >(argp1);
39801 {
39802 PyThreadState* __tstate = wxPyBeginAllowThreads();
39803 wxMenu_Destroy(arg1);
39804 wxPyEndAllowThreads(__tstate);
39805 if (PyErr_Occurred()) SWIG_fail;
39806 }
39807 resultobj = SWIG_Py_Void();
39808 return resultobj;
39809 fail:
39810 return NULL;
39811 }
39812
39813
39814 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39815 PyObject *resultobj = 0;
39816 wxMenu *arg1 = (wxMenu *) 0 ;
39817 int arg2 ;
39818 bool result;
39819 void *argp1 = 0 ;
39820 int res1 = 0 ;
39821 int val2 ;
39822 int ecode2 = 0 ;
39823 PyObject * obj0 = 0 ;
39824 PyObject * obj1 = 0 ;
39825 char * kwnames[] = {
39826 (char *) "self",(char *) "id", NULL
39827 };
39828
39829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39831 if (!SWIG_IsOK(res1)) {
39832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39833 }
39834 arg1 = reinterpret_cast< wxMenu * >(argp1);
39835 ecode2 = SWIG_AsVal_int(obj1, &val2);
39836 if (!SWIG_IsOK(ecode2)) {
39837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39838 }
39839 arg2 = static_cast< int >(val2);
39840 {
39841 PyThreadState* __tstate = wxPyBeginAllowThreads();
39842 result = (bool)(arg1)->Destroy(arg2);
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 {
39847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39848 }
39849 return resultobj;
39850 fail:
39851 return NULL;
39852 }
39853
39854
39855 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39856 PyObject *resultobj = 0;
39857 wxMenu *arg1 = (wxMenu *) 0 ;
39858 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39859 bool result;
39860 void *argp1 = 0 ;
39861 int res1 = 0 ;
39862 void *argp2 = 0 ;
39863 int res2 = 0 ;
39864 PyObject * obj0 = 0 ;
39865 PyObject * obj1 = 0 ;
39866 char * kwnames[] = {
39867 (char *) "self",(char *) "item", NULL
39868 };
39869
39870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39872 if (!SWIG_IsOK(res1)) {
39873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39874 }
39875 arg1 = reinterpret_cast< wxMenu * >(argp1);
39876 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39877 if (!SWIG_IsOK(res2)) {
39878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39879 }
39880 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39881 {
39882 PyThreadState* __tstate = wxPyBeginAllowThreads();
39883 result = (bool)(arg1)->Destroy(arg2);
39884 wxPyEndAllowThreads(__tstate);
39885 if (PyErr_Occurred()) SWIG_fail;
39886 }
39887 {
39888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39889 }
39890 return resultobj;
39891 fail:
39892 return NULL;
39893 }
39894
39895
39896 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39897 PyObject *resultobj = 0;
39898 wxMenu *arg1 = (wxMenu *) 0 ;
39899 size_t result;
39900 void *argp1 = 0 ;
39901 int res1 = 0 ;
39902 PyObject *swig_obj[1] ;
39903
39904 if (!args) SWIG_fail;
39905 swig_obj[0] = args;
39906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39907 if (!SWIG_IsOK(res1)) {
39908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39909 }
39910 arg1 = reinterpret_cast< wxMenu * >(argp1);
39911 {
39912 PyThreadState* __tstate = wxPyBeginAllowThreads();
39913 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39914 wxPyEndAllowThreads(__tstate);
39915 if (PyErr_Occurred()) SWIG_fail;
39916 }
39917 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39918 return resultobj;
39919 fail:
39920 return NULL;
39921 }
39922
39923
39924 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39925 PyObject *resultobj = 0;
39926 wxMenu *arg1 = (wxMenu *) 0 ;
39927 PyObject *result = 0 ;
39928 void *argp1 = 0 ;
39929 int res1 = 0 ;
39930 PyObject *swig_obj[1] ;
39931
39932 if (!args) SWIG_fail;
39933 swig_obj[0] = args;
39934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39935 if (!SWIG_IsOK(res1)) {
39936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39937 }
39938 arg1 = reinterpret_cast< wxMenu * >(argp1);
39939 {
39940 PyThreadState* __tstate = wxPyBeginAllowThreads();
39941 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 resultobj = result;
39946 return resultobj;
39947 fail:
39948 return NULL;
39949 }
39950
39951
39952 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39953 PyObject *resultobj = 0;
39954 wxMenu *arg1 = (wxMenu *) 0 ;
39955 wxString *arg2 = 0 ;
39956 int result;
39957 void *argp1 = 0 ;
39958 int res1 = 0 ;
39959 bool temp2 = false ;
39960 PyObject * obj0 = 0 ;
39961 PyObject * obj1 = 0 ;
39962 char * kwnames[] = {
39963 (char *) "self",(char *) "item", NULL
39964 };
39965
39966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39968 if (!SWIG_IsOK(res1)) {
39969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39970 }
39971 arg1 = reinterpret_cast< wxMenu * >(argp1);
39972 {
39973 arg2 = wxString_in_helper(obj1);
39974 if (arg2 == NULL) SWIG_fail;
39975 temp2 = true;
39976 }
39977 {
39978 PyThreadState* __tstate = wxPyBeginAllowThreads();
39979 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39980 wxPyEndAllowThreads(__tstate);
39981 if (PyErr_Occurred()) SWIG_fail;
39982 }
39983 resultobj = SWIG_From_int(static_cast< int >(result));
39984 {
39985 if (temp2)
39986 delete arg2;
39987 }
39988 return resultobj;
39989 fail:
39990 {
39991 if (temp2)
39992 delete arg2;
39993 }
39994 return NULL;
39995 }
39996
39997
39998 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39999 PyObject *resultobj = 0;
40000 wxMenu *arg1 = (wxMenu *) 0 ;
40001 int arg2 ;
40002 wxMenuItem *result = 0 ;
40003 void *argp1 = 0 ;
40004 int res1 = 0 ;
40005 int val2 ;
40006 int ecode2 = 0 ;
40007 PyObject * obj0 = 0 ;
40008 PyObject * obj1 = 0 ;
40009 char * kwnames[] = {
40010 (char *) "self",(char *) "id", NULL
40011 };
40012
40013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40015 if (!SWIG_IsOK(res1)) {
40016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40017 }
40018 arg1 = reinterpret_cast< wxMenu * >(argp1);
40019 ecode2 = SWIG_AsVal_int(obj1, &val2);
40020 if (!SWIG_IsOK(ecode2)) {
40021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40022 }
40023 arg2 = static_cast< int >(val2);
40024 {
40025 PyThreadState* __tstate = wxPyBeginAllowThreads();
40026 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40027 wxPyEndAllowThreads(__tstate);
40028 if (PyErr_Occurred()) SWIG_fail;
40029 }
40030 {
40031 resultobj = wxPyMake_wxObject(result, (bool)0);
40032 }
40033 return resultobj;
40034 fail:
40035 return NULL;
40036 }
40037
40038
40039 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40040 PyObject *resultobj = 0;
40041 wxMenu *arg1 = (wxMenu *) 0 ;
40042 size_t arg2 ;
40043 wxMenuItem *result = 0 ;
40044 void *argp1 = 0 ;
40045 int res1 = 0 ;
40046 size_t val2 ;
40047 int ecode2 = 0 ;
40048 PyObject * obj0 = 0 ;
40049 PyObject * obj1 = 0 ;
40050 char * kwnames[] = {
40051 (char *) "self",(char *) "position", NULL
40052 };
40053
40054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40056 if (!SWIG_IsOK(res1)) {
40057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40058 }
40059 arg1 = reinterpret_cast< wxMenu * >(argp1);
40060 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40061 if (!SWIG_IsOK(ecode2)) {
40062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40063 }
40064 arg2 = static_cast< size_t >(val2);
40065 {
40066 PyThreadState* __tstate = wxPyBeginAllowThreads();
40067 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40068 wxPyEndAllowThreads(__tstate);
40069 if (PyErr_Occurred()) SWIG_fail;
40070 }
40071 {
40072 resultobj = wxPyMake_wxObject(result, (bool)0);
40073 }
40074 return resultobj;
40075 fail:
40076 return NULL;
40077 }
40078
40079
40080 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40081 PyObject *resultobj = 0;
40082 wxMenu *arg1 = (wxMenu *) 0 ;
40083 int arg2 ;
40084 bool arg3 ;
40085 void *argp1 = 0 ;
40086 int res1 = 0 ;
40087 int val2 ;
40088 int ecode2 = 0 ;
40089 bool val3 ;
40090 int ecode3 = 0 ;
40091 PyObject * obj0 = 0 ;
40092 PyObject * obj1 = 0 ;
40093 PyObject * obj2 = 0 ;
40094 char * kwnames[] = {
40095 (char *) "self",(char *) "id",(char *) "enable", NULL
40096 };
40097
40098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40100 if (!SWIG_IsOK(res1)) {
40101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40102 }
40103 arg1 = reinterpret_cast< wxMenu * >(argp1);
40104 ecode2 = SWIG_AsVal_int(obj1, &val2);
40105 if (!SWIG_IsOK(ecode2)) {
40106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40107 }
40108 arg2 = static_cast< int >(val2);
40109 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40110 if (!SWIG_IsOK(ecode3)) {
40111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40112 }
40113 arg3 = static_cast< bool >(val3);
40114 {
40115 PyThreadState* __tstate = wxPyBeginAllowThreads();
40116 (arg1)->Enable(arg2,arg3);
40117 wxPyEndAllowThreads(__tstate);
40118 if (PyErr_Occurred()) SWIG_fail;
40119 }
40120 resultobj = SWIG_Py_Void();
40121 return resultobj;
40122 fail:
40123 return NULL;
40124 }
40125
40126
40127 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40128 PyObject *resultobj = 0;
40129 wxMenu *arg1 = (wxMenu *) 0 ;
40130 int arg2 ;
40131 bool result;
40132 void *argp1 = 0 ;
40133 int res1 = 0 ;
40134 int val2 ;
40135 int ecode2 = 0 ;
40136 PyObject * obj0 = 0 ;
40137 PyObject * obj1 = 0 ;
40138 char * kwnames[] = {
40139 (char *) "self",(char *) "id", NULL
40140 };
40141
40142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40144 if (!SWIG_IsOK(res1)) {
40145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40146 }
40147 arg1 = reinterpret_cast< wxMenu * >(argp1);
40148 ecode2 = SWIG_AsVal_int(obj1, &val2);
40149 if (!SWIG_IsOK(ecode2)) {
40150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40151 }
40152 arg2 = static_cast< int >(val2);
40153 {
40154 PyThreadState* __tstate = wxPyBeginAllowThreads();
40155 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40156 wxPyEndAllowThreads(__tstate);
40157 if (PyErr_Occurred()) SWIG_fail;
40158 }
40159 {
40160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40161 }
40162 return resultobj;
40163 fail:
40164 return NULL;
40165 }
40166
40167
40168 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40169 PyObject *resultobj = 0;
40170 wxMenu *arg1 = (wxMenu *) 0 ;
40171 int arg2 ;
40172 bool arg3 ;
40173 void *argp1 = 0 ;
40174 int res1 = 0 ;
40175 int val2 ;
40176 int ecode2 = 0 ;
40177 bool val3 ;
40178 int ecode3 = 0 ;
40179 PyObject * obj0 = 0 ;
40180 PyObject * obj1 = 0 ;
40181 PyObject * obj2 = 0 ;
40182 char * kwnames[] = {
40183 (char *) "self",(char *) "id",(char *) "check", NULL
40184 };
40185
40186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40190 }
40191 arg1 = reinterpret_cast< wxMenu * >(argp1);
40192 ecode2 = SWIG_AsVal_int(obj1, &val2);
40193 if (!SWIG_IsOK(ecode2)) {
40194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40195 }
40196 arg2 = static_cast< int >(val2);
40197 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40198 if (!SWIG_IsOK(ecode3)) {
40199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40200 }
40201 arg3 = static_cast< bool >(val3);
40202 {
40203 PyThreadState* __tstate = wxPyBeginAllowThreads();
40204 (arg1)->Check(arg2,arg3);
40205 wxPyEndAllowThreads(__tstate);
40206 if (PyErr_Occurred()) SWIG_fail;
40207 }
40208 resultobj = SWIG_Py_Void();
40209 return resultobj;
40210 fail:
40211 return NULL;
40212 }
40213
40214
40215 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40216 PyObject *resultobj = 0;
40217 wxMenu *arg1 = (wxMenu *) 0 ;
40218 int arg2 ;
40219 bool result;
40220 void *argp1 = 0 ;
40221 int res1 = 0 ;
40222 int val2 ;
40223 int ecode2 = 0 ;
40224 PyObject * obj0 = 0 ;
40225 PyObject * obj1 = 0 ;
40226 char * kwnames[] = {
40227 (char *) "self",(char *) "id", NULL
40228 };
40229
40230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40232 if (!SWIG_IsOK(res1)) {
40233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40234 }
40235 arg1 = reinterpret_cast< wxMenu * >(argp1);
40236 ecode2 = SWIG_AsVal_int(obj1, &val2);
40237 if (!SWIG_IsOK(ecode2)) {
40238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40239 }
40240 arg2 = static_cast< int >(val2);
40241 {
40242 PyThreadState* __tstate = wxPyBeginAllowThreads();
40243 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40244 wxPyEndAllowThreads(__tstate);
40245 if (PyErr_Occurred()) SWIG_fail;
40246 }
40247 {
40248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40249 }
40250 return resultobj;
40251 fail:
40252 return NULL;
40253 }
40254
40255
40256 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40257 PyObject *resultobj = 0;
40258 wxMenu *arg1 = (wxMenu *) 0 ;
40259 int arg2 ;
40260 wxString *arg3 = 0 ;
40261 void *argp1 = 0 ;
40262 int res1 = 0 ;
40263 int val2 ;
40264 int ecode2 = 0 ;
40265 bool temp3 = false ;
40266 PyObject * obj0 = 0 ;
40267 PyObject * obj1 = 0 ;
40268 PyObject * obj2 = 0 ;
40269 char * kwnames[] = {
40270 (char *) "self",(char *) "id",(char *) "label", NULL
40271 };
40272
40273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40275 if (!SWIG_IsOK(res1)) {
40276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40277 }
40278 arg1 = reinterpret_cast< wxMenu * >(argp1);
40279 ecode2 = SWIG_AsVal_int(obj1, &val2);
40280 if (!SWIG_IsOK(ecode2)) {
40281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40282 }
40283 arg2 = static_cast< int >(val2);
40284 {
40285 arg3 = wxString_in_helper(obj2);
40286 if (arg3 == NULL) SWIG_fail;
40287 temp3 = true;
40288 }
40289 {
40290 PyThreadState* __tstate = wxPyBeginAllowThreads();
40291 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40292 wxPyEndAllowThreads(__tstate);
40293 if (PyErr_Occurred()) SWIG_fail;
40294 }
40295 resultobj = SWIG_Py_Void();
40296 {
40297 if (temp3)
40298 delete arg3;
40299 }
40300 return resultobj;
40301 fail:
40302 {
40303 if (temp3)
40304 delete arg3;
40305 }
40306 return NULL;
40307 }
40308
40309
40310 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj = 0;
40312 wxMenu *arg1 = (wxMenu *) 0 ;
40313 int arg2 ;
40314 wxString result;
40315 void *argp1 = 0 ;
40316 int res1 = 0 ;
40317 int val2 ;
40318 int ecode2 = 0 ;
40319 PyObject * obj0 = 0 ;
40320 PyObject * obj1 = 0 ;
40321 char * kwnames[] = {
40322 (char *) "self",(char *) "id", NULL
40323 };
40324
40325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40327 if (!SWIG_IsOK(res1)) {
40328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40329 }
40330 arg1 = reinterpret_cast< wxMenu * >(argp1);
40331 ecode2 = SWIG_AsVal_int(obj1, &val2);
40332 if (!SWIG_IsOK(ecode2)) {
40333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40334 }
40335 arg2 = static_cast< int >(val2);
40336 {
40337 PyThreadState* __tstate = wxPyBeginAllowThreads();
40338 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40339 wxPyEndAllowThreads(__tstate);
40340 if (PyErr_Occurred()) SWIG_fail;
40341 }
40342 {
40343 #if wxUSE_UNICODE
40344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40345 #else
40346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40347 #endif
40348 }
40349 return resultobj;
40350 fail:
40351 return NULL;
40352 }
40353
40354
40355 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40356 PyObject *resultobj = 0;
40357 wxMenu *arg1 = (wxMenu *) 0 ;
40358 int arg2 ;
40359 wxString *arg3 = 0 ;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 int val2 ;
40363 int ecode2 = 0 ;
40364 bool temp3 = false ;
40365 PyObject * obj0 = 0 ;
40366 PyObject * obj1 = 0 ;
40367 PyObject * obj2 = 0 ;
40368 char * kwnames[] = {
40369 (char *) "self",(char *) "id",(char *) "helpString", NULL
40370 };
40371
40372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40374 if (!SWIG_IsOK(res1)) {
40375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40376 }
40377 arg1 = reinterpret_cast< wxMenu * >(argp1);
40378 ecode2 = SWIG_AsVal_int(obj1, &val2);
40379 if (!SWIG_IsOK(ecode2)) {
40380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40381 }
40382 arg2 = static_cast< int >(val2);
40383 {
40384 arg3 = wxString_in_helper(obj2);
40385 if (arg3 == NULL) SWIG_fail;
40386 temp3 = true;
40387 }
40388 {
40389 PyThreadState* __tstate = wxPyBeginAllowThreads();
40390 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40391 wxPyEndAllowThreads(__tstate);
40392 if (PyErr_Occurred()) SWIG_fail;
40393 }
40394 resultobj = SWIG_Py_Void();
40395 {
40396 if (temp3)
40397 delete arg3;
40398 }
40399 return resultobj;
40400 fail:
40401 {
40402 if (temp3)
40403 delete arg3;
40404 }
40405 return NULL;
40406 }
40407
40408
40409 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40410 PyObject *resultobj = 0;
40411 wxMenu *arg1 = (wxMenu *) 0 ;
40412 int arg2 ;
40413 wxString result;
40414 void *argp1 = 0 ;
40415 int res1 = 0 ;
40416 int val2 ;
40417 int ecode2 = 0 ;
40418 PyObject * obj0 = 0 ;
40419 PyObject * obj1 = 0 ;
40420 char * kwnames[] = {
40421 (char *) "self",(char *) "id", NULL
40422 };
40423
40424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40426 if (!SWIG_IsOK(res1)) {
40427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40428 }
40429 arg1 = reinterpret_cast< wxMenu * >(argp1);
40430 ecode2 = SWIG_AsVal_int(obj1, &val2);
40431 if (!SWIG_IsOK(ecode2)) {
40432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40433 }
40434 arg2 = static_cast< int >(val2);
40435 {
40436 PyThreadState* __tstate = wxPyBeginAllowThreads();
40437 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40438 wxPyEndAllowThreads(__tstate);
40439 if (PyErr_Occurred()) SWIG_fail;
40440 }
40441 {
40442 #if wxUSE_UNICODE
40443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40444 #else
40445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40446 #endif
40447 }
40448 return resultobj;
40449 fail:
40450 return NULL;
40451 }
40452
40453
40454 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40455 PyObject *resultobj = 0;
40456 wxMenu *arg1 = (wxMenu *) 0 ;
40457 wxString *arg2 = 0 ;
40458 void *argp1 = 0 ;
40459 int res1 = 0 ;
40460 bool temp2 = false ;
40461 PyObject * obj0 = 0 ;
40462 PyObject * obj1 = 0 ;
40463 char * kwnames[] = {
40464 (char *) "self",(char *) "title", NULL
40465 };
40466
40467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40469 if (!SWIG_IsOK(res1)) {
40470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40471 }
40472 arg1 = reinterpret_cast< wxMenu * >(argp1);
40473 {
40474 arg2 = wxString_in_helper(obj1);
40475 if (arg2 == NULL) SWIG_fail;
40476 temp2 = true;
40477 }
40478 {
40479 PyThreadState* __tstate = wxPyBeginAllowThreads();
40480 (arg1)->SetTitle((wxString const &)*arg2);
40481 wxPyEndAllowThreads(__tstate);
40482 if (PyErr_Occurred()) SWIG_fail;
40483 }
40484 resultobj = SWIG_Py_Void();
40485 {
40486 if (temp2)
40487 delete arg2;
40488 }
40489 return resultobj;
40490 fail:
40491 {
40492 if (temp2)
40493 delete arg2;
40494 }
40495 return NULL;
40496 }
40497
40498
40499 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40500 PyObject *resultobj = 0;
40501 wxMenu *arg1 = (wxMenu *) 0 ;
40502 wxString result;
40503 void *argp1 = 0 ;
40504 int res1 = 0 ;
40505 PyObject *swig_obj[1] ;
40506
40507 if (!args) SWIG_fail;
40508 swig_obj[0] = args;
40509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40510 if (!SWIG_IsOK(res1)) {
40511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40512 }
40513 arg1 = reinterpret_cast< wxMenu * >(argp1);
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 result = ((wxMenu const *)arg1)->GetTitle();
40517 wxPyEndAllowThreads(__tstate);
40518 if (PyErr_Occurred()) SWIG_fail;
40519 }
40520 {
40521 #if wxUSE_UNICODE
40522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40523 #else
40524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40525 #endif
40526 }
40527 return resultobj;
40528 fail:
40529 return NULL;
40530 }
40531
40532
40533 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40534 PyObject *resultobj = 0;
40535 wxMenu *arg1 = (wxMenu *) 0 ;
40536 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40537 void *argp1 = 0 ;
40538 int res1 = 0 ;
40539 void *argp2 = 0 ;
40540 int res2 = 0 ;
40541 PyObject * obj0 = 0 ;
40542 PyObject * obj1 = 0 ;
40543 char * kwnames[] = {
40544 (char *) "self",(char *) "handler", NULL
40545 };
40546
40547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40549 if (!SWIG_IsOK(res1)) {
40550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40551 }
40552 arg1 = reinterpret_cast< wxMenu * >(argp1);
40553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40554 if (!SWIG_IsOK(res2)) {
40555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40556 }
40557 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40558 {
40559 PyThreadState* __tstate = wxPyBeginAllowThreads();
40560 (arg1)->SetEventHandler(arg2);
40561 wxPyEndAllowThreads(__tstate);
40562 if (PyErr_Occurred()) SWIG_fail;
40563 }
40564 resultobj = SWIG_Py_Void();
40565 return resultobj;
40566 fail:
40567 return NULL;
40568 }
40569
40570
40571 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40572 PyObject *resultobj = 0;
40573 wxMenu *arg1 = (wxMenu *) 0 ;
40574 wxEvtHandler *result = 0 ;
40575 void *argp1 = 0 ;
40576 int res1 = 0 ;
40577 PyObject *swig_obj[1] ;
40578
40579 if (!args) SWIG_fail;
40580 swig_obj[0] = args;
40581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40582 if (!SWIG_IsOK(res1)) {
40583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40584 }
40585 arg1 = reinterpret_cast< wxMenu * >(argp1);
40586 {
40587 PyThreadState* __tstate = wxPyBeginAllowThreads();
40588 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40589 wxPyEndAllowThreads(__tstate);
40590 if (PyErr_Occurred()) SWIG_fail;
40591 }
40592 {
40593 resultobj = wxPyMake_wxObject(result, 0);
40594 }
40595 return resultobj;
40596 fail:
40597 return NULL;
40598 }
40599
40600
40601 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40602 PyObject *resultobj = 0;
40603 wxMenu *arg1 = (wxMenu *) 0 ;
40604 wxWindow *arg2 = (wxWindow *) 0 ;
40605 void *argp1 = 0 ;
40606 int res1 = 0 ;
40607 void *argp2 = 0 ;
40608 int res2 = 0 ;
40609 PyObject * obj0 = 0 ;
40610 PyObject * obj1 = 0 ;
40611 char * kwnames[] = {
40612 (char *) "self",(char *) "win", NULL
40613 };
40614
40615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40617 if (!SWIG_IsOK(res1)) {
40618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40619 }
40620 arg1 = reinterpret_cast< wxMenu * >(argp1);
40621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40622 if (!SWIG_IsOK(res2)) {
40623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40624 }
40625 arg2 = reinterpret_cast< wxWindow * >(argp2);
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 (arg1)->SetInvokingWindow(arg2);
40629 wxPyEndAllowThreads(__tstate);
40630 if (PyErr_Occurred()) SWIG_fail;
40631 }
40632 resultobj = SWIG_Py_Void();
40633 return resultobj;
40634 fail:
40635 return NULL;
40636 }
40637
40638
40639 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40640 PyObject *resultobj = 0;
40641 wxMenu *arg1 = (wxMenu *) 0 ;
40642 wxWindow *result = 0 ;
40643 void *argp1 = 0 ;
40644 int res1 = 0 ;
40645 PyObject *swig_obj[1] ;
40646
40647 if (!args) SWIG_fail;
40648 swig_obj[0] = args;
40649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40650 if (!SWIG_IsOK(res1)) {
40651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40652 }
40653 arg1 = reinterpret_cast< wxMenu * >(argp1);
40654 {
40655 PyThreadState* __tstate = wxPyBeginAllowThreads();
40656 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 {
40661 resultobj = wxPyMake_wxObject(result, 0);
40662 }
40663 return resultobj;
40664 fail:
40665 return NULL;
40666 }
40667
40668
40669 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40670 PyObject *resultobj = 0;
40671 wxMenu *arg1 = (wxMenu *) 0 ;
40672 long result;
40673 void *argp1 = 0 ;
40674 int res1 = 0 ;
40675 PyObject *swig_obj[1] ;
40676
40677 if (!args) SWIG_fail;
40678 swig_obj[0] = args;
40679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40680 if (!SWIG_IsOK(res1)) {
40681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40682 }
40683 arg1 = reinterpret_cast< wxMenu * >(argp1);
40684 {
40685 PyThreadState* __tstate = wxPyBeginAllowThreads();
40686 result = (long)((wxMenu const *)arg1)->GetStyle();
40687 wxPyEndAllowThreads(__tstate);
40688 if (PyErr_Occurred()) SWIG_fail;
40689 }
40690 resultobj = SWIG_From_long(static_cast< long >(result));
40691 return resultobj;
40692 fail:
40693 return NULL;
40694 }
40695
40696
40697 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40698 PyObject *resultobj = 0;
40699 wxMenu *arg1 = (wxMenu *) 0 ;
40700 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40701 void *argp1 = 0 ;
40702 int res1 = 0 ;
40703 void *argp2 = 0 ;
40704 int res2 = 0 ;
40705 PyObject * obj0 = 0 ;
40706 PyObject * obj1 = 0 ;
40707 char * kwnames[] = {
40708 (char *) "self",(char *) "source", NULL
40709 };
40710
40711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40713 if (!SWIG_IsOK(res1)) {
40714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40715 }
40716 arg1 = reinterpret_cast< wxMenu * >(argp1);
40717 if (obj1) {
40718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40719 if (!SWIG_IsOK(res2)) {
40720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40721 }
40722 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40723 }
40724 {
40725 PyThreadState* __tstate = wxPyBeginAllowThreads();
40726 (arg1)->UpdateUI(arg2);
40727 wxPyEndAllowThreads(__tstate);
40728 if (PyErr_Occurred()) SWIG_fail;
40729 }
40730 resultobj = SWIG_Py_Void();
40731 return resultobj;
40732 fail:
40733 return NULL;
40734 }
40735
40736
40737 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40738 PyObject *resultobj = 0;
40739 wxMenu *arg1 = (wxMenu *) 0 ;
40740 wxMenuBar *result = 0 ;
40741 void *argp1 = 0 ;
40742 int res1 = 0 ;
40743 PyObject *swig_obj[1] ;
40744
40745 if (!args) SWIG_fail;
40746 swig_obj[0] = args;
40747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40748 if (!SWIG_IsOK(res1)) {
40749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40750 }
40751 arg1 = reinterpret_cast< wxMenu * >(argp1);
40752 {
40753 PyThreadState* __tstate = wxPyBeginAllowThreads();
40754 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40755 wxPyEndAllowThreads(__tstate);
40756 if (PyErr_Occurred()) SWIG_fail;
40757 }
40758 {
40759 resultobj = wxPyMake_wxObject(result, (bool)0);
40760 }
40761 return resultobj;
40762 fail:
40763 return NULL;
40764 }
40765
40766
40767 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40768 PyObject *resultobj = 0;
40769 wxMenu *arg1 = (wxMenu *) 0 ;
40770 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40771 void *argp1 = 0 ;
40772 int res1 = 0 ;
40773 void *argp2 = 0 ;
40774 int res2 = 0 ;
40775 PyObject * obj0 = 0 ;
40776 PyObject * obj1 = 0 ;
40777 char * kwnames[] = {
40778 (char *) "self",(char *) "menubar", NULL
40779 };
40780
40781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40783 if (!SWIG_IsOK(res1)) {
40784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40785 }
40786 arg1 = reinterpret_cast< wxMenu * >(argp1);
40787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40788 if (!SWIG_IsOK(res2)) {
40789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40790 }
40791 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40792 {
40793 PyThreadState* __tstate = wxPyBeginAllowThreads();
40794 (arg1)->Attach(arg2);
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_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40806 PyObject *resultobj = 0;
40807 wxMenu *arg1 = (wxMenu *) 0 ;
40808 void *argp1 = 0 ;
40809 int res1 = 0 ;
40810 PyObject *swig_obj[1] ;
40811
40812 if (!args) SWIG_fail;
40813 swig_obj[0] = args;
40814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40815 if (!SWIG_IsOK(res1)) {
40816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40817 }
40818 arg1 = reinterpret_cast< wxMenu * >(argp1);
40819 {
40820 PyThreadState* __tstate = wxPyBeginAllowThreads();
40821 (arg1)->Detach();
40822 wxPyEndAllowThreads(__tstate);
40823 if (PyErr_Occurred()) SWIG_fail;
40824 }
40825 resultobj = SWIG_Py_Void();
40826 return resultobj;
40827 fail:
40828 return NULL;
40829 }
40830
40831
40832 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40833 PyObject *resultobj = 0;
40834 wxMenu *arg1 = (wxMenu *) 0 ;
40835 bool result;
40836 void *argp1 = 0 ;
40837 int res1 = 0 ;
40838 PyObject *swig_obj[1] ;
40839
40840 if (!args) SWIG_fail;
40841 swig_obj[0] = args;
40842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40843 if (!SWIG_IsOK(res1)) {
40844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40845 }
40846 arg1 = reinterpret_cast< wxMenu * >(argp1);
40847 {
40848 PyThreadState* __tstate = wxPyBeginAllowThreads();
40849 result = (bool)((wxMenu const *)arg1)->IsAttached();
40850 wxPyEndAllowThreads(__tstate);
40851 if (PyErr_Occurred()) SWIG_fail;
40852 }
40853 {
40854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40855 }
40856 return resultobj;
40857 fail:
40858 return NULL;
40859 }
40860
40861
40862 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40863 PyObject *resultobj = 0;
40864 wxMenu *arg1 = (wxMenu *) 0 ;
40865 wxMenu *arg2 = (wxMenu *) 0 ;
40866 void *argp1 = 0 ;
40867 int res1 = 0 ;
40868 void *argp2 = 0 ;
40869 int res2 = 0 ;
40870 PyObject * obj0 = 0 ;
40871 PyObject * obj1 = 0 ;
40872 char * kwnames[] = {
40873 (char *) "self",(char *) "parent", NULL
40874 };
40875
40876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40878 if (!SWIG_IsOK(res1)) {
40879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40880 }
40881 arg1 = reinterpret_cast< wxMenu * >(argp1);
40882 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40883 if (!SWIG_IsOK(res2)) {
40884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40885 }
40886 arg2 = reinterpret_cast< wxMenu * >(argp2);
40887 {
40888 PyThreadState* __tstate = wxPyBeginAllowThreads();
40889 (arg1)->SetParent(arg2);
40890 wxPyEndAllowThreads(__tstate);
40891 if (PyErr_Occurred()) SWIG_fail;
40892 }
40893 resultobj = SWIG_Py_Void();
40894 return resultobj;
40895 fail:
40896 return NULL;
40897 }
40898
40899
40900 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40901 PyObject *resultobj = 0;
40902 wxMenu *arg1 = (wxMenu *) 0 ;
40903 wxMenu *result = 0 ;
40904 void *argp1 = 0 ;
40905 int res1 = 0 ;
40906 PyObject *swig_obj[1] ;
40907
40908 if (!args) SWIG_fail;
40909 swig_obj[0] = args;
40910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40911 if (!SWIG_IsOK(res1)) {
40912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40913 }
40914 arg1 = reinterpret_cast< wxMenu * >(argp1);
40915 {
40916 PyThreadState* __tstate = wxPyBeginAllowThreads();
40917 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40918 wxPyEndAllowThreads(__tstate);
40919 if (PyErr_Occurred()) SWIG_fail;
40920 }
40921 {
40922 resultobj = wxPyMake_wxObject(result, 0);
40923 }
40924 return resultobj;
40925 fail:
40926 return NULL;
40927 }
40928
40929
40930 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40931 PyObject *obj;
40932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40933 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40934 return SWIG_Py_Void();
40935 }
40936
40937 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40938 return SWIG_Python_InitShadowInstance(args);
40939 }
40940
40941 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj = 0;
40943 long arg1 = (long) 0 ;
40944 wxMenuBar *result = 0 ;
40945 long val1 ;
40946 int ecode1 = 0 ;
40947 PyObject * obj0 = 0 ;
40948 char * kwnames[] = {
40949 (char *) "style", NULL
40950 };
40951
40952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40953 if (obj0) {
40954 ecode1 = SWIG_AsVal_long(obj0, &val1);
40955 if (!SWIG_IsOK(ecode1)) {
40956 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40957 }
40958 arg1 = static_cast< long >(val1);
40959 }
40960 {
40961 if (!wxPyCheckForApp()) SWIG_fail;
40962 PyThreadState* __tstate = wxPyBeginAllowThreads();
40963 result = (wxMenuBar *)new wxMenuBar(arg1);
40964 wxPyEndAllowThreads(__tstate);
40965 if (PyErr_Occurred()) SWIG_fail;
40966 }
40967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40968 return resultobj;
40969 fail:
40970 return NULL;
40971 }
40972
40973
40974 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40975 PyObject *resultobj = 0;
40976 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40977 wxMenu *arg2 = (wxMenu *) 0 ;
40978 wxString *arg3 = 0 ;
40979 bool result;
40980 void *argp1 = 0 ;
40981 int res1 = 0 ;
40982 void *argp2 = 0 ;
40983 int res2 = 0 ;
40984 bool temp3 = false ;
40985 PyObject * obj0 = 0 ;
40986 PyObject * obj1 = 0 ;
40987 PyObject * obj2 = 0 ;
40988 char * kwnames[] = {
40989 (char *) "self",(char *) "menu",(char *) "title", NULL
40990 };
40991
40992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40994 if (!SWIG_IsOK(res1)) {
40995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40996 }
40997 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40999 if (!SWIG_IsOK(res2)) {
41000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41001 }
41002 arg2 = reinterpret_cast< wxMenu * >(argp2);
41003 {
41004 arg3 = wxString_in_helper(obj2);
41005 if (arg3 == NULL) SWIG_fail;
41006 temp3 = true;
41007 }
41008 {
41009 PyThreadState* __tstate = wxPyBeginAllowThreads();
41010 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 {
41015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41016 }
41017 {
41018 if (temp3)
41019 delete arg3;
41020 }
41021 return resultobj;
41022 fail:
41023 {
41024 if (temp3)
41025 delete arg3;
41026 }
41027 return NULL;
41028 }
41029
41030
41031 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41032 PyObject *resultobj = 0;
41033 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41034 size_t arg2 ;
41035 wxMenu *arg3 = (wxMenu *) 0 ;
41036 wxString *arg4 = 0 ;
41037 bool result;
41038 void *argp1 = 0 ;
41039 int res1 = 0 ;
41040 size_t val2 ;
41041 int ecode2 = 0 ;
41042 void *argp3 = 0 ;
41043 int res3 = 0 ;
41044 bool temp4 = false ;
41045 PyObject * obj0 = 0 ;
41046 PyObject * obj1 = 0 ;
41047 PyObject * obj2 = 0 ;
41048 PyObject * obj3 = 0 ;
41049 char * kwnames[] = {
41050 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41051 };
41052
41053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41055 if (!SWIG_IsOK(res1)) {
41056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41057 }
41058 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41059 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41060 if (!SWIG_IsOK(ecode2)) {
41061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41062 }
41063 arg2 = static_cast< size_t >(val2);
41064 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41065 if (!SWIG_IsOK(res3)) {
41066 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41067 }
41068 arg3 = reinterpret_cast< wxMenu * >(argp3);
41069 {
41070 arg4 = wxString_in_helper(obj3);
41071 if (arg4 == NULL) SWIG_fail;
41072 temp4 = true;
41073 }
41074 {
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41077 wxPyEndAllowThreads(__tstate);
41078 if (PyErr_Occurred()) SWIG_fail;
41079 }
41080 {
41081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41082 }
41083 {
41084 if (temp4)
41085 delete arg4;
41086 }
41087 return resultobj;
41088 fail:
41089 {
41090 if (temp4)
41091 delete arg4;
41092 }
41093 return NULL;
41094 }
41095
41096
41097 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41098 PyObject *resultobj = 0;
41099 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41100 size_t result;
41101 void *argp1 = 0 ;
41102 int res1 = 0 ;
41103 PyObject *swig_obj[1] ;
41104
41105 if (!args) SWIG_fail;
41106 swig_obj[0] = args;
41107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41108 if (!SWIG_IsOK(res1)) {
41109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41110 }
41111 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41112 {
41113 PyThreadState* __tstate = wxPyBeginAllowThreads();
41114 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41115 wxPyEndAllowThreads(__tstate);
41116 if (PyErr_Occurred()) SWIG_fail;
41117 }
41118 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41119 return resultobj;
41120 fail:
41121 return NULL;
41122 }
41123
41124
41125 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41126 PyObject *resultobj = 0;
41127 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41128 size_t arg2 ;
41129 wxMenu *result = 0 ;
41130 void *argp1 = 0 ;
41131 int res1 = 0 ;
41132 size_t val2 ;
41133 int ecode2 = 0 ;
41134 PyObject * obj0 = 0 ;
41135 PyObject * obj1 = 0 ;
41136 char * kwnames[] = {
41137 (char *) "self",(char *) "pos", NULL
41138 };
41139
41140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41142 if (!SWIG_IsOK(res1)) {
41143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41144 }
41145 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41146 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41147 if (!SWIG_IsOK(ecode2)) {
41148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41149 }
41150 arg2 = static_cast< size_t >(val2);
41151 {
41152 PyThreadState* __tstate = wxPyBeginAllowThreads();
41153 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41154 wxPyEndAllowThreads(__tstate);
41155 if (PyErr_Occurred()) SWIG_fail;
41156 }
41157 {
41158 resultobj = wxPyMake_wxObject(result, 0);
41159 }
41160 return resultobj;
41161 fail:
41162 return NULL;
41163 }
41164
41165
41166 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41167 PyObject *resultobj = 0;
41168 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41169 size_t arg2 ;
41170 wxMenu *arg3 = (wxMenu *) 0 ;
41171 wxString *arg4 = 0 ;
41172 wxMenu *result = 0 ;
41173 void *argp1 = 0 ;
41174 int res1 = 0 ;
41175 size_t val2 ;
41176 int ecode2 = 0 ;
41177 void *argp3 = 0 ;
41178 int res3 = 0 ;
41179 bool temp4 = false ;
41180 PyObject * obj0 = 0 ;
41181 PyObject * obj1 = 0 ;
41182 PyObject * obj2 = 0 ;
41183 PyObject * obj3 = 0 ;
41184 char * kwnames[] = {
41185 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41186 };
41187
41188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41190 if (!SWIG_IsOK(res1)) {
41191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41192 }
41193 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41194 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41195 if (!SWIG_IsOK(ecode2)) {
41196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41197 }
41198 arg2 = static_cast< size_t >(val2);
41199 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41200 if (!SWIG_IsOK(res3)) {
41201 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41202 }
41203 arg3 = reinterpret_cast< wxMenu * >(argp3);
41204 {
41205 arg4 = wxString_in_helper(obj3);
41206 if (arg4 == NULL) SWIG_fail;
41207 temp4 = true;
41208 }
41209 {
41210 PyThreadState* __tstate = wxPyBeginAllowThreads();
41211 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41212 wxPyEndAllowThreads(__tstate);
41213 if (PyErr_Occurred()) SWIG_fail;
41214 }
41215 {
41216 resultobj = wxPyMake_wxObject(result, 0);
41217 }
41218 {
41219 if (temp4)
41220 delete arg4;
41221 }
41222 return resultobj;
41223 fail:
41224 {
41225 if (temp4)
41226 delete arg4;
41227 }
41228 return NULL;
41229 }
41230
41231
41232 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41233 PyObject *resultobj = 0;
41234 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41235 size_t arg2 ;
41236 wxMenu *result = 0 ;
41237 void *argp1 = 0 ;
41238 int res1 = 0 ;
41239 size_t val2 ;
41240 int ecode2 = 0 ;
41241 PyObject * obj0 = 0 ;
41242 PyObject * obj1 = 0 ;
41243 char * kwnames[] = {
41244 (char *) "self",(char *) "pos", NULL
41245 };
41246
41247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41249 if (!SWIG_IsOK(res1)) {
41250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41251 }
41252 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41253 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41254 if (!SWIG_IsOK(ecode2)) {
41255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41256 }
41257 arg2 = static_cast< size_t >(val2);
41258 {
41259 PyThreadState* __tstate = wxPyBeginAllowThreads();
41260 result = (wxMenu *)(arg1)->Remove(arg2);
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 {
41265 resultobj = wxPyMake_wxObject(result, 0);
41266 }
41267 return resultobj;
41268 fail:
41269 return NULL;
41270 }
41271
41272
41273 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41274 PyObject *resultobj = 0;
41275 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41276 size_t arg2 ;
41277 bool arg3 ;
41278 void *argp1 = 0 ;
41279 int res1 = 0 ;
41280 size_t val2 ;
41281 int ecode2 = 0 ;
41282 bool val3 ;
41283 int ecode3 = 0 ;
41284 PyObject * obj0 = 0 ;
41285 PyObject * obj1 = 0 ;
41286 PyObject * obj2 = 0 ;
41287 char * kwnames[] = {
41288 (char *) "self",(char *) "pos",(char *) "enable", NULL
41289 };
41290
41291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41293 if (!SWIG_IsOK(res1)) {
41294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41295 }
41296 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41297 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41298 if (!SWIG_IsOK(ecode2)) {
41299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41300 }
41301 arg2 = static_cast< size_t >(val2);
41302 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41303 if (!SWIG_IsOK(ecode3)) {
41304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41305 }
41306 arg3 = static_cast< bool >(val3);
41307 {
41308 PyThreadState* __tstate = wxPyBeginAllowThreads();
41309 (arg1)->EnableTop(arg2,arg3);
41310 wxPyEndAllowThreads(__tstate);
41311 if (PyErr_Occurred()) SWIG_fail;
41312 }
41313 resultobj = SWIG_Py_Void();
41314 return resultobj;
41315 fail:
41316 return NULL;
41317 }
41318
41319
41320 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41321 PyObject *resultobj = 0;
41322 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41323 size_t arg2 ;
41324 bool result;
41325 void *argp1 = 0 ;
41326 int res1 = 0 ;
41327 size_t val2 ;
41328 int ecode2 = 0 ;
41329 PyObject * obj0 = 0 ;
41330 PyObject * obj1 = 0 ;
41331 char * kwnames[] = {
41332 (char *) "self",(char *) "pos", NULL
41333 };
41334
41335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41337 if (!SWIG_IsOK(res1)) {
41338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41339 }
41340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41341 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41342 if (!SWIG_IsOK(ecode2)) {
41343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41344 }
41345 arg2 = static_cast< size_t >(val2);
41346 {
41347 PyThreadState* __tstate = wxPyBeginAllowThreads();
41348 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41349 wxPyEndAllowThreads(__tstate);
41350 if (PyErr_Occurred()) SWIG_fail;
41351 }
41352 {
41353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41354 }
41355 return resultobj;
41356 fail:
41357 return NULL;
41358 }
41359
41360
41361 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41362 PyObject *resultobj = 0;
41363 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41364 size_t arg2 ;
41365 wxString *arg3 = 0 ;
41366 void *argp1 = 0 ;
41367 int res1 = 0 ;
41368 size_t val2 ;
41369 int ecode2 = 0 ;
41370 bool temp3 = false ;
41371 PyObject * obj0 = 0 ;
41372 PyObject * obj1 = 0 ;
41373 PyObject * obj2 = 0 ;
41374 char * kwnames[] = {
41375 (char *) "self",(char *) "pos",(char *) "label", NULL
41376 };
41377
41378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41380 if (!SWIG_IsOK(res1)) {
41381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41382 }
41383 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41384 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41385 if (!SWIG_IsOK(ecode2)) {
41386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41387 }
41388 arg2 = static_cast< size_t >(val2);
41389 {
41390 arg3 = wxString_in_helper(obj2);
41391 if (arg3 == NULL) SWIG_fail;
41392 temp3 = true;
41393 }
41394 {
41395 PyThreadState* __tstate = wxPyBeginAllowThreads();
41396 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41397 wxPyEndAllowThreads(__tstate);
41398 if (PyErr_Occurred()) SWIG_fail;
41399 }
41400 resultobj = SWIG_Py_Void();
41401 {
41402 if (temp3)
41403 delete arg3;
41404 }
41405 return resultobj;
41406 fail:
41407 {
41408 if (temp3)
41409 delete arg3;
41410 }
41411 return NULL;
41412 }
41413
41414
41415 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41416 PyObject *resultobj = 0;
41417 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41418 size_t arg2 ;
41419 wxString result;
41420 void *argp1 = 0 ;
41421 int res1 = 0 ;
41422 size_t val2 ;
41423 int ecode2 = 0 ;
41424 PyObject * obj0 = 0 ;
41425 PyObject * obj1 = 0 ;
41426 char * kwnames[] = {
41427 (char *) "self",(char *) "pos", NULL
41428 };
41429
41430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41432 if (!SWIG_IsOK(res1)) {
41433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41434 }
41435 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41436 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41437 if (!SWIG_IsOK(ecode2)) {
41438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41439 }
41440 arg2 = static_cast< size_t >(val2);
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 {
41448 #if wxUSE_UNICODE
41449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41450 #else
41451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41452 #endif
41453 }
41454 return resultobj;
41455 fail:
41456 return NULL;
41457 }
41458
41459
41460 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41461 PyObject *resultobj = 0;
41462 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41463 wxString *arg2 = 0 ;
41464 wxString *arg3 = 0 ;
41465 int result;
41466 void *argp1 = 0 ;
41467 int res1 = 0 ;
41468 bool temp2 = false ;
41469 bool temp3 = false ;
41470 PyObject * obj0 = 0 ;
41471 PyObject * obj1 = 0 ;
41472 PyObject * obj2 = 0 ;
41473 char * kwnames[] = {
41474 (char *) "self",(char *) "menu",(char *) "item", NULL
41475 };
41476
41477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41479 if (!SWIG_IsOK(res1)) {
41480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41481 }
41482 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41483 {
41484 arg2 = wxString_in_helper(obj1);
41485 if (arg2 == NULL) SWIG_fail;
41486 temp2 = true;
41487 }
41488 {
41489 arg3 = wxString_in_helper(obj2);
41490 if (arg3 == NULL) SWIG_fail;
41491 temp3 = true;
41492 }
41493 {
41494 PyThreadState* __tstate = wxPyBeginAllowThreads();
41495 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41496 wxPyEndAllowThreads(__tstate);
41497 if (PyErr_Occurred()) SWIG_fail;
41498 }
41499 resultobj = SWIG_From_int(static_cast< int >(result));
41500 {
41501 if (temp2)
41502 delete arg2;
41503 }
41504 {
41505 if (temp3)
41506 delete arg3;
41507 }
41508 return resultobj;
41509 fail:
41510 {
41511 if (temp2)
41512 delete arg2;
41513 }
41514 {
41515 if (temp3)
41516 delete arg3;
41517 }
41518 return NULL;
41519 }
41520
41521
41522 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj = 0;
41524 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41525 int arg2 ;
41526 wxMenuItem *result = 0 ;
41527 void *argp1 = 0 ;
41528 int res1 = 0 ;
41529 int val2 ;
41530 int ecode2 = 0 ;
41531 PyObject * obj0 = 0 ;
41532 PyObject * obj1 = 0 ;
41533 char * kwnames[] = {
41534 (char *) "self",(char *) "id", NULL
41535 };
41536
41537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41539 if (!SWIG_IsOK(res1)) {
41540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41541 }
41542 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41543 ecode2 = SWIG_AsVal_int(obj1, &val2);
41544 if (!SWIG_IsOK(ecode2)) {
41545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41546 }
41547 arg2 = static_cast< int >(val2);
41548 {
41549 PyThreadState* __tstate = wxPyBeginAllowThreads();
41550 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41551 wxPyEndAllowThreads(__tstate);
41552 if (PyErr_Occurred()) SWIG_fail;
41553 }
41554 {
41555 resultobj = wxPyMake_wxObject(result, (bool)0);
41556 }
41557 return resultobj;
41558 fail:
41559 return NULL;
41560 }
41561
41562
41563 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41564 PyObject *resultobj = 0;
41565 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41566 wxString *arg2 = 0 ;
41567 int result;
41568 void *argp1 = 0 ;
41569 int res1 = 0 ;
41570 bool temp2 = false ;
41571 PyObject * obj0 = 0 ;
41572 PyObject * obj1 = 0 ;
41573 char * kwnames[] = {
41574 (char *) "self",(char *) "title", NULL
41575 };
41576
41577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41579 if (!SWIG_IsOK(res1)) {
41580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41581 }
41582 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41583 {
41584 arg2 = wxString_in_helper(obj1);
41585 if (arg2 == NULL) SWIG_fail;
41586 temp2 = true;
41587 }
41588 {
41589 PyThreadState* __tstate = wxPyBeginAllowThreads();
41590 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41591 wxPyEndAllowThreads(__tstate);
41592 if (PyErr_Occurred()) SWIG_fail;
41593 }
41594 resultobj = SWIG_From_int(static_cast< int >(result));
41595 {
41596 if (temp2)
41597 delete arg2;
41598 }
41599 return resultobj;
41600 fail:
41601 {
41602 if (temp2)
41603 delete arg2;
41604 }
41605 return NULL;
41606 }
41607
41608
41609 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41610 PyObject *resultobj = 0;
41611 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41612 int arg2 ;
41613 bool arg3 ;
41614 void *argp1 = 0 ;
41615 int res1 = 0 ;
41616 int val2 ;
41617 int ecode2 = 0 ;
41618 bool val3 ;
41619 int ecode3 = 0 ;
41620 PyObject * obj0 = 0 ;
41621 PyObject * obj1 = 0 ;
41622 PyObject * obj2 = 0 ;
41623 char * kwnames[] = {
41624 (char *) "self",(char *) "id",(char *) "enable", NULL
41625 };
41626
41627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41629 if (!SWIG_IsOK(res1)) {
41630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41631 }
41632 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41633 ecode2 = SWIG_AsVal_int(obj1, &val2);
41634 if (!SWIG_IsOK(ecode2)) {
41635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41636 }
41637 arg2 = static_cast< int >(val2);
41638 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41639 if (!SWIG_IsOK(ecode3)) {
41640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41641 }
41642 arg3 = static_cast< bool >(val3);
41643 {
41644 PyThreadState* __tstate = wxPyBeginAllowThreads();
41645 (arg1)->Enable(arg2,arg3);
41646 wxPyEndAllowThreads(__tstate);
41647 if (PyErr_Occurred()) SWIG_fail;
41648 }
41649 resultobj = SWIG_Py_Void();
41650 return resultobj;
41651 fail:
41652 return NULL;
41653 }
41654
41655
41656 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41657 PyObject *resultobj = 0;
41658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41659 int arg2 ;
41660 bool arg3 ;
41661 void *argp1 = 0 ;
41662 int res1 = 0 ;
41663 int val2 ;
41664 int ecode2 = 0 ;
41665 bool val3 ;
41666 int ecode3 = 0 ;
41667 PyObject * obj0 = 0 ;
41668 PyObject * obj1 = 0 ;
41669 PyObject * obj2 = 0 ;
41670 char * kwnames[] = {
41671 (char *) "self",(char *) "id",(char *) "check", NULL
41672 };
41673
41674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41676 if (!SWIG_IsOK(res1)) {
41677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41678 }
41679 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41680 ecode2 = SWIG_AsVal_int(obj1, &val2);
41681 if (!SWIG_IsOK(ecode2)) {
41682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41683 }
41684 arg2 = static_cast< int >(val2);
41685 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41686 if (!SWIG_IsOK(ecode3)) {
41687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41688 }
41689 arg3 = static_cast< bool >(val3);
41690 {
41691 PyThreadState* __tstate = wxPyBeginAllowThreads();
41692 (arg1)->Check(arg2,arg3);
41693 wxPyEndAllowThreads(__tstate);
41694 if (PyErr_Occurred()) SWIG_fail;
41695 }
41696 resultobj = SWIG_Py_Void();
41697 return resultobj;
41698 fail:
41699 return NULL;
41700 }
41701
41702
41703 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41704 PyObject *resultobj = 0;
41705 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41706 int arg2 ;
41707 bool result;
41708 void *argp1 = 0 ;
41709 int res1 = 0 ;
41710 int val2 ;
41711 int ecode2 = 0 ;
41712 PyObject * obj0 = 0 ;
41713 PyObject * obj1 = 0 ;
41714 char * kwnames[] = {
41715 (char *) "self",(char *) "id", NULL
41716 };
41717
41718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41720 if (!SWIG_IsOK(res1)) {
41721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41722 }
41723 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41724 ecode2 = SWIG_AsVal_int(obj1, &val2);
41725 if (!SWIG_IsOK(ecode2)) {
41726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41727 }
41728 arg2 = static_cast< int >(val2);
41729 {
41730 PyThreadState* __tstate = wxPyBeginAllowThreads();
41731 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41732 wxPyEndAllowThreads(__tstate);
41733 if (PyErr_Occurred()) SWIG_fail;
41734 }
41735 {
41736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41737 }
41738 return resultobj;
41739 fail:
41740 return NULL;
41741 }
41742
41743
41744 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41745 PyObject *resultobj = 0;
41746 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41747 int arg2 ;
41748 bool result;
41749 void *argp1 = 0 ;
41750 int res1 = 0 ;
41751 int val2 ;
41752 int ecode2 = 0 ;
41753 PyObject * obj0 = 0 ;
41754 PyObject * obj1 = 0 ;
41755 char * kwnames[] = {
41756 (char *) "self",(char *) "id", NULL
41757 };
41758
41759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41761 if (!SWIG_IsOK(res1)) {
41762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41763 }
41764 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41765 ecode2 = SWIG_AsVal_int(obj1, &val2);
41766 if (!SWIG_IsOK(ecode2)) {
41767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41768 }
41769 arg2 = static_cast< int >(val2);
41770 {
41771 PyThreadState* __tstate = wxPyBeginAllowThreads();
41772 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41773 wxPyEndAllowThreads(__tstate);
41774 if (PyErr_Occurred()) SWIG_fail;
41775 }
41776 {
41777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41778 }
41779 return resultobj;
41780 fail:
41781 return NULL;
41782 }
41783
41784
41785 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41786 PyObject *resultobj = 0;
41787 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41788 int arg2 ;
41789 wxString *arg3 = 0 ;
41790 void *argp1 = 0 ;
41791 int res1 = 0 ;
41792 int val2 ;
41793 int ecode2 = 0 ;
41794 bool temp3 = false ;
41795 PyObject * obj0 = 0 ;
41796 PyObject * obj1 = 0 ;
41797 PyObject * obj2 = 0 ;
41798 char * kwnames[] = {
41799 (char *) "self",(char *) "id",(char *) "label", NULL
41800 };
41801
41802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41804 if (!SWIG_IsOK(res1)) {
41805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41806 }
41807 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41808 ecode2 = SWIG_AsVal_int(obj1, &val2);
41809 if (!SWIG_IsOK(ecode2)) {
41810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41811 }
41812 arg2 = static_cast< int >(val2);
41813 {
41814 arg3 = wxString_in_helper(obj2);
41815 if (arg3 == NULL) SWIG_fail;
41816 temp3 = true;
41817 }
41818 {
41819 PyThreadState* __tstate = wxPyBeginAllowThreads();
41820 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41821 wxPyEndAllowThreads(__tstate);
41822 if (PyErr_Occurred()) SWIG_fail;
41823 }
41824 resultobj = SWIG_Py_Void();
41825 {
41826 if (temp3)
41827 delete arg3;
41828 }
41829 return resultobj;
41830 fail:
41831 {
41832 if (temp3)
41833 delete arg3;
41834 }
41835 return NULL;
41836 }
41837
41838
41839 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41840 PyObject *resultobj = 0;
41841 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41842 int arg2 ;
41843 wxString result;
41844 void *argp1 = 0 ;
41845 int res1 = 0 ;
41846 int val2 ;
41847 int ecode2 = 0 ;
41848 PyObject * obj0 = 0 ;
41849 PyObject * obj1 = 0 ;
41850 char * kwnames[] = {
41851 (char *) "self",(char *) "id", NULL
41852 };
41853
41854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41856 if (!SWIG_IsOK(res1)) {
41857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41858 }
41859 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41860 ecode2 = SWIG_AsVal_int(obj1, &val2);
41861 if (!SWIG_IsOK(ecode2)) {
41862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41863 }
41864 arg2 = static_cast< int >(val2);
41865 {
41866 PyThreadState* __tstate = wxPyBeginAllowThreads();
41867 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41868 wxPyEndAllowThreads(__tstate);
41869 if (PyErr_Occurred()) SWIG_fail;
41870 }
41871 {
41872 #if wxUSE_UNICODE
41873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41874 #else
41875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41876 #endif
41877 }
41878 return resultobj;
41879 fail:
41880 return NULL;
41881 }
41882
41883
41884 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41885 PyObject *resultobj = 0;
41886 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41887 int arg2 ;
41888 wxString *arg3 = 0 ;
41889 void *argp1 = 0 ;
41890 int res1 = 0 ;
41891 int val2 ;
41892 int ecode2 = 0 ;
41893 bool temp3 = false ;
41894 PyObject * obj0 = 0 ;
41895 PyObject * obj1 = 0 ;
41896 PyObject * obj2 = 0 ;
41897 char * kwnames[] = {
41898 (char *) "self",(char *) "id",(char *) "helpString", NULL
41899 };
41900
41901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41903 if (!SWIG_IsOK(res1)) {
41904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41905 }
41906 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41907 ecode2 = SWIG_AsVal_int(obj1, &val2);
41908 if (!SWIG_IsOK(ecode2)) {
41909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41910 }
41911 arg2 = static_cast< int >(val2);
41912 {
41913 arg3 = wxString_in_helper(obj2);
41914 if (arg3 == NULL) SWIG_fail;
41915 temp3 = true;
41916 }
41917 {
41918 PyThreadState* __tstate = wxPyBeginAllowThreads();
41919 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41920 wxPyEndAllowThreads(__tstate);
41921 if (PyErr_Occurred()) SWIG_fail;
41922 }
41923 resultobj = SWIG_Py_Void();
41924 {
41925 if (temp3)
41926 delete arg3;
41927 }
41928 return resultobj;
41929 fail:
41930 {
41931 if (temp3)
41932 delete arg3;
41933 }
41934 return NULL;
41935 }
41936
41937
41938 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41939 PyObject *resultobj = 0;
41940 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41941 int arg2 ;
41942 wxString result;
41943 void *argp1 = 0 ;
41944 int res1 = 0 ;
41945 int val2 ;
41946 int ecode2 = 0 ;
41947 PyObject * obj0 = 0 ;
41948 PyObject * obj1 = 0 ;
41949 char * kwnames[] = {
41950 (char *) "self",(char *) "id", NULL
41951 };
41952
41953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41955 if (!SWIG_IsOK(res1)) {
41956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41957 }
41958 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41959 ecode2 = SWIG_AsVal_int(obj1, &val2);
41960 if (!SWIG_IsOK(ecode2)) {
41961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41962 }
41963 arg2 = static_cast< int >(val2);
41964 {
41965 PyThreadState* __tstate = wxPyBeginAllowThreads();
41966 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41967 wxPyEndAllowThreads(__tstate);
41968 if (PyErr_Occurred()) SWIG_fail;
41969 }
41970 {
41971 #if wxUSE_UNICODE
41972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41973 #else
41974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41975 #endif
41976 }
41977 return resultobj;
41978 fail:
41979 return NULL;
41980 }
41981
41982
41983 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41984 PyObject *resultobj = 0;
41985 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41986 wxFrame *result = 0 ;
41987 void *argp1 = 0 ;
41988 int res1 = 0 ;
41989 PyObject *swig_obj[1] ;
41990
41991 if (!args) SWIG_fail;
41992 swig_obj[0] = args;
41993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41994 if (!SWIG_IsOK(res1)) {
41995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41996 }
41997 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41998 {
41999 PyThreadState* __tstate = wxPyBeginAllowThreads();
42000 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42001 wxPyEndAllowThreads(__tstate);
42002 if (PyErr_Occurred()) SWIG_fail;
42003 }
42004 {
42005 resultobj = wxPyMake_wxObject(result, (bool)0);
42006 }
42007 return resultobj;
42008 fail:
42009 return NULL;
42010 }
42011
42012
42013 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42014 PyObject *resultobj = 0;
42015 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42016 bool result;
42017 void *argp1 = 0 ;
42018 int res1 = 0 ;
42019 PyObject *swig_obj[1] ;
42020
42021 if (!args) SWIG_fail;
42022 swig_obj[0] = args;
42023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42024 if (!SWIG_IsOK(res1)) {
42025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42026 }
42027 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42028 {
42029 PyThreadState* __tstate = wxPyBeginAllowThreads();
42030 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42031 wxPyEndAllowThreads(__tstate);
42032 if (PyErr_Occurred()) SWIG_fail;
42033 }
42034 {
42035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42036 }
42037 return resultobj;
42038 fail:
42039 return NULL;
42040 }
42041
42042
42043 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42044 PyObject *resultobj = 0;
42045 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42046 wxFrame *arg2 = (wxFrame *) 0 ;
42047 void *argp1 = 0 ;
42048 int res1 = 0 ;
42049 void *argp2 = 0 ;
42050 int res2 = 0 ;
42051 PyObject * obj0 = 0 ;
42052 PyObject * obj1 = 0 ;
42053 char * kwnames[] = {
42054 (char *) "self",(char *) "frame", NULL
42055 };
42056
42057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42059 if (!SWIG_IsOK(res1)) {
42060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42061 }
42062 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42063 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42064 if (!SWIG_IsOK(res2)) {
42065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42066 }
42067 arg2 = reinterpret_cast< wxFrame * >(argp2);
42068 {
42069 PyThreadState* __tstate = wxPyBeginAllowThreads();
42070 (arg1)->Attach(arg2);
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_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42082 PyObject *resultobj = 0;
42083 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42084 void *argp1 = 0 ;
42085 int res1 = 0 ;
42086 PyObject *swig_obj[1] ;
42087
42088 if (!args) SWIG_fail;
42089 swig_obj[0] = args;
42090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42091 if (!SWIG_IsOK(res1)) {
42092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42093 }
42094 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42095 {
42096 PyThreadState* __tstate = wxPyBeginAllowThreads();
42097 (arg1)->Detach();
42098 wxPyEndAllowThreads(__tstate);
42099 if (PyErr_Occurred()) SWIG_fail;
42100 }
42101 resultobj = SWIG_Py_Void();
42102 return resultobj;
42103 fail:
42104 return NULL;
42105 }
42106
42107
42108 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42109 PyObject *resultobj = 0;
42110 bool arg1 ;
42111 bool val1 ;
42112 int ecode1 = 0 ;
42113 PyObject * obj0 = 0 ;
42114 char * kwnames[] = {
42115 (char *) "enable", NULL
42116 };
42117
42118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42119 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42120 if (!SWIG_IsOK(ecode1)) {
42121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42122 }
42123 arg1 = static_cast< bool >(val1);
42124 {
42125 PyThreadState* __tstate = wxPyBeginAllowThreads();
42126 wxMenuBar_SetAutoWindowMenu(arg1);
42127 wxPyEndAllowThreads(__tstate);
42128 if (PyErr_Occurred()) SWIG_fail;
42129 }
42130 resultobj = SWIG_Py_Void();
42131 return resultobj;
42132 fail:
42133 return NULL;
42134 }
42135
42136
42137 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42138 PyObject *resultobj = 0;
42139 bool result;
42140
42141 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42142 {
42143 PyThreadState* __tstate = wxPyBeginAllowThreads();
42144 result = (bool)wxMenuBar_GetAutoWindowMenu();
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 {
42149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42150 }
42151 return resultobj;
42152 fail:
42153 return NULL;
42154 }
42155
42156
42157 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42158 PyObject *obj;
42159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42160 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42161 return SWIG_Py_Void();
42162 }
42163
42164 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42165 return SWIG_Python_InitShadowInstance(args);
42166 }
42167
42168 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42169 PyObject *resultobj = 0;
42170 wxMenu *arg1 = (wxMenu *) NULL ;
42171 int arg2 = (int) wxID_ANY ;
42172 wxString const &arg3_defvalue = wxPyEmptyString ;
42173 wxString *arg3 = (wxString *) &arg3_defvalue ;
42174 wxString const &arg4_defvalue = wxPyEmptyString ;
42175 wxString *arg4 = (wxString *) &arg4_defvalue ;
42176 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42177 wxMenu *arg6 = (wxMenu *) NULL ;
42178 wxMenuItem *result = 0 ;
42179 void *argp1 = 0 ;
42180 int res1 = 0 ;
42181 int val2 ;
42182 int ecode2 = 0 ;
42183 bool temp3 = false ;
42184 bool temp4 = false ;
42185 int val5 ;
42186 int ecode5 = 0 ;
42187 void *argp6 = 0 ;
42188 int res6 = 0 ;
42189 PyObject * obj0 = 0 ;
42190 PyObject * obj1 = 0 ;
42191 PyObject * obj2 = 0 ;
42192 PyObject * obj3 = 0 ;
42193 PyObject * obj4 = 0 ;
42194 PyObject * obj5 = 0 ;
42195 char * kwnames[] = {
42196 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42197 };
42198
42199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42200 if (obj0) {
42201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42202 if (!SWIG_IsOK(res1)) {
42203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42204 }
42205 arg1 = reinterpret_cast< wxMenu * >(argp1);
42206 }
42207 if (obj1) {
42208 ecode2 = SWIG_AsVal_int(obj1, &val2);
42209 if (!SWIG_IsOK(ecode2)) {
42210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42211 }
42212 arg2 = static_cast< int >(val2);
42213 }
42214 if (obj2) {
42215 {
42216 arg3 = wxString_in_helper(obj2);
42217 if (arg3 == NULL) SWIG_fail;
42218 temp3 = true;
42219 }
42220 }
42221 if (obj3) {
42222 {
42223 arg4 = wxString_in_helper(obj3);
42224 if (arg4 == NULL) SWIG_fail;
42225 temp4 = true;
42226 }
42227 }
42228 if (obj4) {
42229 ecode5 = SWIG_AsVal_int(obj4, &val5);
42230 if (!SWIG_IsOK(ecode5)) {
42231 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42232 }
42233 arg5 = static_cast< wxItemKind >(val5);
42234 }
42235 if (obj5) {
42236 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42237 if (!SWIG_IsOK(res6)) {
42238 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42239 }
42240 arg6 = reinterpret_cast< wxMenu * >(argp6);
42241 }
42242 {
42243 PyThreadState* __tstate = wxPyBeginAllowThreads();
42244 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42245 wxPyEndAllowThreads(__tstate);
42246 if (PyErr_Occurred()) SWIG_fail;
42247 }
42248 {
42249 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42250 }
42251 {
42252 if (temp3)
42253 delete arg3;
42254 }
42255 {
42256 if (temp4)
42257 delete arg4;
42258 }
42259 return resultobj;
42260 fail:
42261 {
42262 if (temp3)
42263 delete arg3;
42264 }
42265 {
42266 if (temp4)
42267 delete arg4;
42268 }
42269 return NULL;
42270 }
42271
42272
42273 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42274 PyObject *resultobj = 0;
42275 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42276 void *argp1 = 0 ;
42277 int res1 = 0 ;
42278 PyObject *swig_obj[1] ;
42279
42280 if (!args) SWIG_fail;
42281 swig_obj[0] = args;
42282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42283 if (!SWIG_IsOK(res1)) {
42284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42285 }
42286 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42287 {
42288 PyThreadState* __tstate = wxPyBeginAllowThreads();
42289 delete arg1;
42290
42291 wxPyEndAllowThreads(__tstate);
42292 if (PyErr_Occurred()) SWIG_fail;
42293 }
42294 resultobj = SWIG_Py_Void();
42295 return resultobj;
42296 fail:
42297 return NULL;
42298 }
42299
42300
42301 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42302 PyObject *resultobj = 0;
42303 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42304 wxMenu *result = 0 ;
42305 void *argp1 = 0 ;
42306 int res1 = 0 ;
42307 PyObject *swig_obj[1] ;
42308
42309 if (!args) SWIG_fail;
42310 swig_obj[0] = args;
42311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42312 if (!SWIG_IsOK(res1)) {
42313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42314 }
42315 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42316 {
42317 PyThreadState* __tstate = wxPyBeginAllowThreads();
42318 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42319 wxPyEndAllowThreads(__tstate);
42320 if (PyErr_Occurred()) SWIG_fail;
42321 }
42322 {
42323 resultobj = wxPyMake_wxObject(result, 0);
42324 }
42325 return resultobj;
42326 fail:
42327 return NULL;
42328 }
42329
42330
42331 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42332 PyObject *resultobj = 0;
42333 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42334 wxMenu *arg2 = (wxMenu *) 0 ;
42335 void *argp1 = 0 ;
42336 int res1 = 0 ;
42337 void *argp2 = 0 ;
42338 int res2 = 0 ;
42339 PyObject * obj0 = 0 ;
42340 PyObject * obj1 = 0 ;
42341 char * kwnames[] = {
42342 (char *) "self",(char *) "menu", NULL
42343 };
42344
42345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42347 if (!SWIG_IsOK(res1)) {
42348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42349 }
42350 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42352 if (!SWIG_IsOK(res2)) {
42353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42354 }
42355 arg2 = reinterpret_cast< wxMenu * >(argp2);
42356 {
42357 PyThreadState* __tstate = wxPyBeginAllowThreads();
42358 (arg1)->SetMenu(arg2);
42359 wxPyEndAllowThreads(__tstate);
42360 if (PyErr_Occurred()) SWIG_fail;
42361 }
42362 resultobj = SWIG_Py_Void();
42363 return resultobj;
42364 fail:
42365 return NULL;
42366 }
42367
42368
42369 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42370 PyObject *resultobj = 0;
42371 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42372 int arg2 ;
42373 void *argp1 = 0 ;
42374 int res1 = 0 ;
42375 int val2 ;
42376 int ecode2 = 0 ;
42377 PyObject * obj0 = 0 ;
42378 PyObject * obj1 = 0 ;
42379 char * kwnames[] = {
42380 (char *) "self",(char *) "id", NULL
42381 };
42382
42383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42385 if (!SWIG_IsOK(res1)) {
42386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42387 }
42388 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42389 ecode2 = SWIG_AsVal_int(obj1, &val2);
42390 if (!SWIG_IsOK(ecode2)) {
42391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42392 }
42393 arg2 = static_cast< int >(val2);
42394 {
42395 PyThreadState* __tstate = wxPyBeginAllowThreads();
42396 (arg1)->SetId(arg2);
42397 wxPyEndAllowThreads(__tstate);
42398 if (PyErr_Occurred()) SWIG_fail;
42399 }
42400 resultobj = SWIG_Py_Void();
42401 return resultobj;
42402 fail:
42403 return NULL;
42404 }
42405
42406
42407 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42408 PyObject *resultobj = 0;
42409 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42410 int result;
42411 void *argp1 = 0 ;
42412 int res1 = 0 ;
42413 PyObject *swig_obj[1] ;
42414
42415 if (!args) SWIG_fail;
42416 swig_obj[0] = args;
42417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42418 if (!SWIG_IsOK(res1)) {
42419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42420 }
42421 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42422 {
42423 PyThreadState* __tstate = wxPyBeginAllowThreads();
42424 result = (int)((wxMenuItem const *)arg1)->GetId();
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 resultobj = SWIG_From_int(static_cast< int >(result));
42429 return resultobj;
42430 fail:
42431 return NULL;
42432 }
42433
42434
42435 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42436 PyObject *resultobj = 0;
42437 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42438 bool result;
42439 void *argp1 = 0 ;
42440 int res1 = 0 ;
42441 PyObject *swig_obj[1] ;
42442
42443 if (!args) SWIG_fail;
42444 swig_obj[0] = args;
42445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42446 if (!SWIG_IsOK(res1)) {
42447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42448 }
42449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42450 {
42451 PyThreadState* __tstate = wxPyBeginAllowThreads();
42452 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42453 wxPyEndAllowThreads(__tstate);
42454 if (PyErr_Occurred()) SWIG_fail;
42455 }
42456 {
42457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42458 }
42459 return resultobj;
42460 fail:
42461 return NULL;
42462 }
42463
42464
42465 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42466 PyObject *resultobj = 0;
42467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42468 wxString *arg2 = 0 ;
42469 void *argp1 = 0 ;
42470 int res1 = 0 ;
42471 bool temp2 = false ;
42472 PyObject * obj0 = 0 ;
42473 PyObject * obj1 = 0 ;
42474 char * kwnames[] = {
42475 (char *) "self",(char *) "str", NULL
42476 };
42477
42478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42480 if (!SWIG_IsOK(res1)) {
42481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42482 }
42483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42484 {
42485 arg2 = wxString_in_helper(obj1);
42486 if (arg2 == NULL) SWIG_fail;
42487 temp2 = true;
42488 }
42489 {
42490 PyThreadState* __tstate = wxPyBeginAllowThreads();
42491 (arg1)->SetText((wxString const &)*arg2);
42492 wxPyEndAllowThreads(__tstate);
42493 if (PyErr_Occurred()) SWIG_fail;
42494 }
42495 resultobj = SWIG_Py_Void();
42496 {
42497 if (temp2)
42498 delete arg2;
42499 }
42500 return resultobj;
42501 fail:
42502 {
42503 if (temp2)
42504 delete arg2;
42505 }
42506 return NULL;
42507 }
42508
42509
42510 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42511 PyObject *resultobj = 0;
42512 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42513 wxString result;
42514 void *argp1 = 0 ;
42515 int res1 = 0 ;
42516 PyObject *swig_obj[1] ;
42517
42518 if (!args) SWIG_fail;
42519 swig_obj[0] = args;
42520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42521 if (!SWIG_IsOK(res1)) {
42522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42523 }
42524 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42525 {
42526 PyThreadState* __tstate = wxPyBeginAllowThreads();
42527 result = ((wxMenuItem const *)arg1)->GetLabel();
42528 wxPyEndAllowThreads(__tstate);
42529 if (PyErr_Occurred()) SWIG_fail;
42530 }
42531 {
42532 #if wxUSE_UNICODE
42533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42534 #else
42535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42536 #endif
42537 }
42538 return resultobj;
42539 fail:
42540 return NULL;
42541 }
42542
42543
42544 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42545 PyObject *resultobj = 0;
42546 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42547 wxString *result = 0 ;
42548 void *argp1 = 0 ;
42549 int res1 = 0 ;
42550 PyObject *swig_obj[1] ;
42551
42552 if (!args) SWIG_fail;
42553 swig_obj[0] = args;
42554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42555 if (!SWIG_IsOK(res1)) {
42556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42557 }
42558 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42559 {
42560 PyThreadState* __tstate = wxPyBeginAllowThreads();
42561 {
42562 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42563 result = (wxString *) &_result_ref;
42564 }
42565 wxPyEndAllowThreads(__tstate);
42566 if (PyErr_Occurred()) SWIG_fail;
42567 }
42568 {
42569 #if wxUSE_UNICODE
42570 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42571 #else
42572 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42573 #endif
42574 }
42575 return resultobj;
42576 fail:
42577 return NULL;
42578 }
42579
42580
42581 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42582 PyObject *resultobj = 0;
42583 wxString *arg1 = 0 ;
42584 wxString result;
42585 bool temp1 = false ;
42586 PyObject * obj0 = 0 ;
42587 char * kwnames[] = {
42588 (char *) "text", NULL
42589 };
42590
42591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42592 {
42593 arg1 = wxString_in_helper(obj0);
42594 if (arg1 == NULL) SWIG_fail;
42595 temp1 = true;
42596 }
42597 {
42598 PyThreadState* __tstate = wxPyBeginAllowThreads();
42599 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42600 wxPyEndAllowThreads(__tstate);
42601 if (PyErr_Occurred()) SWIG_fail;
42602 }
42603 {
42604 #if wxUSE_UNICODE
42605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42606 #else
42607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42608 #endif
42609 }
42610 {
42611 if (temp1)
42612 delete arg1;
42613 }
42614 return resultobj;
42615 fail:
42616 {
42617 if (temp1)
42618 delete arg1;
42619 }
42620 return NULL;
42621 }
42622
42623
42624 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42625 PyObject *resultobj = 0;
42626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42627 wxItemKind result;
42628 void *argp1 = 0 ;
42629 int res1 = 0 ;
42630 PyObject *swig_obj[1] ;
42631
42632 if (!args) SWIG_fail;
42633 swig_obj[0] = args;
42634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42635 if (!SWIG_IsOK(res1)) {
42636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42637 }
42638 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42639 {
42640 PyThreadState* __tstate = wxPyBeginAllowThreads();
42641 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42642 wxPyEndAllowThreads(__tstate);
42643 if (PyErr_Occurred()) SWIG_fail;
42644 }
42645 resultobj = SWIG_From_int(static_cast< int >(result));
42646 return resultobj;
42647 fail:
42648 return NULL;
42649 }
42650
42651
42652 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42653 PyObject *resultobj = 0;
42654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42655 wxItemKind arg2 ;
42656 void *argp1 = 0 ;
42657 int res1 = 0 ;
42658 int val2 ;
42659 int ecode2 = 0 ;
42660 PyObject * obj0 = 0 ;
42661 PyObject * obj1 = 0 ;
42662 char * kwnames[] = {
42663 (char *) "self",(char *) "kind", NULL
42664 };
42665
42666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42668 if (!SWIG_IsOK(res1)) {
42669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42670 }
42671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42672 ecode2 = SWIG_AsVal_int(obj1, &val2);
42673 if (!SWIG_IsOK(ecode2)) {
42674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42675 }
42676 arg2 = static_cast< wxItemKind >(val2);
42677 {
42678 PyThreadState* __tstate = wxPyBeginAllowThreads();
42679 (arg1)->SetKind(arg2);
42680 wxPyEndAllowThreads(__tstate);
42681 if (PyErr_Occurred()) SWIG_fail;
42682 }
42683 resultobj = SWIG_Py_Void();
42684 return resultobj;
42685 fail:
42686 return NULL;
42687 }
42688
42689
42690 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42691 PyObject *resultobj = 0;
42692 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42693 bool arg2 ;
42694 void *argp1 = 0 ;
42695 int res1 = 0 ;
42696 bool val2 ;
42697 int ecode2 = 0 ;
42698 PyObject * obj0 = 0 ;
42699 PyObject * obj1 = 0 ;
42700 char * kwnames[] = {
42701 (char *) "self",(char *) "checkable", NULL
42702 };
42703
42704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42706 if (!SWIG_IsOK(res1)) {
42707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42708 }
42709 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42711 if (!SWIG_IsOK(ecode2)) {
42712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42713 }
42714 arg2 = static_cast< bool >(val2);
42715 {
42716 PyThreadState* __tstate = wxPyBeginAllowThreads();
42717 (arg1)->SetCheckable(arg2);
42718 wxPyEndAllowThreads(__tstate);
42719 if (PyErr_Occurred()) SWIG_fail;
42720 }
42721 resultobj = SWIG_Py_Void();
42722 return resultobj;
42723 fail:
42724 return NULL;
42725 }
42726
42727
42728 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42729 PyObject *resultobj = 0;
42730 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42731 bool result;
42732 void *argp1 = 0 ;
42733 int res1 = 0 ;
42734 PyObject *swig_obj[1] ;
42735
42736 if (!args) SWIG_fail;
42737 swig_obj[0] = args;
42738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42739 if (!SWIG_IsOK(res1)) {
42740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42741 }
42742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42743 {
42744 PyThreadState* __tstate = wxPyBeginAllowThreads();
42745 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42746 wxPyEndAllowThreads(__tstate);
42747 if (PyErr_Occurred()) SWIG_fail;
42748 }
42749 {
42750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42751 }
42752 return resultobj;
42753 fail:
42754 return NULL;
42755 }
42756
42757
42758 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42759 PyObject *resultobj = 0;
42760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42761 bool result;
42762 void *argp1 = 0 ;
42763 int res1 = 0 ;
42764 PyObject *swig_obj[1] ;
42765
42766 if (!args) SWIG_fail;
42767 swig_obj[0] = args;
42768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42769 if (!SWIG_IsOK(res1)) {
42770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42771 }
42772 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42773 {
42774 PyThreadState* __tstate = wxPyBeginAllowThreads();
42775 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42776 wxPyEndAllowThreads(__tstate);
42777 if (PyErr_Occurred()) SWIG_fail;
42778 }
42779 {
42780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42781 }
42782 return resultobj;
42783 fail:
42784 return NULL;
42785 }
42786
42787
42788 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42789 PyObject *resultobj = 0;
42790 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42791 wxMenu *arg2 = (wxMenu *) 0 ;
42792 void *argp1 = 0 ;
42793 int res1 = 0 ;
42794 void *argp2 = 0 ;
42795 int res2 = 0 ;
42796 PyObject * obj0 = 0 ;
42797 PyObject * obj1 = 0 ;
42798 char * kwnames[] = {
42799 (char *) "self",(char *) "menu", NULL
42800 };
42801
42802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42804 if (!SWIG_IsOK(res1)) {
42805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42806 }
42807 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42808 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42809 if (!SWIG_IsOK(res2)) {
42810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42811 }
42812 arg2 = reinterpret_cast< wxMenu * >(argp2);
42813 {
42814 PyThreadState* __tstate = wxPyBeginAllowThreads();
42815 (arg1)->SetSubMenu(arg2);
42816 wxPyEndAllowThreads(__tstate);
42817 if (PyErr_Occurred()) SWIG_fail;
42818 }
42819 resultobj = SWIG_Py_Void();
42820 return resultobj;
42821 fail:
42822 return NULL;
42823 }
42824
42825
42826 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42827 PyObject *resultobj = 0;
42828 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42829 wxMenu *result = 0 ;
42830 void *argp1 = 0 ;
42831 int res1 = 0 ;
42832 PyObject *swig_obj[1] ;
42833
42834 if (!args) SWIG_fail;
42835 swig_obj[0] = args;
42836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42837 if (!SWIG_IsOK(res1)) {
42838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42839 }
42840 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42841 {
42842 PyThreadState* __tstate = wxPyBeginAllowThreads();
42843 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42844 wxPyEndAllowThreads(__tstate);
42845 if (PyErr_Occurred()) SWIG_fail;
42846 }
42847 {
42848 resultobj = wxPyMake_wxObject(result, 0);
42849 }
42850 return resultobj;
42851 fail:
42852 return NULL;
42853 }
42854
42855
42856 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42857 PyObject *resultobj = 0;
42858 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42859 bool arg2 = (bool) true ;
42860 void *argp1 = 0 ;
42861 int res1 = 0 ;
42862 bool val2 ;
42863 int ecode2 = 0 ;
42864 PyObject * obj0 = 0 ;
42865 PyObject * obj1 = 0 ;
42866 char * kwnames[] = {
42867 (char *) "self",(char *) "enable", NULL
42868 };
42869
42870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42872 if (!SWIG_IsOK(res1)) {
42873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42874 }
42875 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42876 if (obj1) {
42877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42878 if (!SWIG_IsOK(ecode2)) {
42879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42880 }
42881 arg2 = static_cast< bool >(val2);
42882 }
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 (arg1)->Enable(arg2);
42886 wxPyEndAllowThreads(__tstate);
42887 if (PyErr_Occurred()) SWIG_fail;
42888 }
42889 resultobj = SWIG_Py_Void();
42890 return resultobj;
42891 fail:
42892 return NULL;
42893 }
42894
42895
42896 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42897 PyObject *resultobj = 0;
42898 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42899 bool result;
42900 void *argp1 = 0 ;
42901 int res1 = 0 ;
42902 PyObject *swig_obj[1] ;
42903
42904 if (!args) SWIG_fail;
42905 swig_obj[0] = args;
42906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42907 if (!SWIG_IsOK(res1)) {
42908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42909 }
42910 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42911 {
42912 PyThreadState* __tstate = wxPyBeginAllowThreads();
42913 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42914 wxPyEndAllowThreads(__tstate);
42915 if (PyErr_Occurred()) SWIG_fail;
42916 }
42917 {
42918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42919 }
42920 return resultobj;
42921 fail:
42922 return NULL;
42923 }
42924
42925
42926 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42927 PyObject *resultobj = 0;
42928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42929 bool arg2 = (bool) true ;
42930 void *argp1 = 0 ;
42931 int res1 = 0 ;
42932 bool val2 ;
42933 int ecode2 = 0 ;
42934 PyObject * obj0 = 0 ;
42935 PyObject * obj1 = 0 ;
42936 char * kwnames[] = {
42937 (char *) "self",(char *) "check", NULL
42938 };
42939
42940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42942 if (!SWIG_IsOK(res1)) {
42943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42944 }
42945 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42946 if (obj1) {
42947 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42948 if (!SWIG_IsOK(ecode2)) {
42949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42950 }
42951 arg2 = static_cast< bool >(val2);
42952 }
42953 {
42954 PyThreadState* __tstate = wxPyBeginAllowThreads();
42955 (arg1)->Check(arg2);
42956 wxPyEndAllowThreads(__tstate);
42957 if (PyErr_Occurred()) SWIG_fail;
42958 }
42959 resultobj = SWIG_Py_Void();
42960 return resultobj;
42961 fail:
42962 return NULL;
42963 }
42964
42965
42966 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42967 PyObject *resultobj = 0;
42968 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42969 bool result;
42970 void *argp1 = 0 ;
42971 int res1 = 0 ;
42972 PyObject *swig_obj[1] ;
42973
42974 if (!args) SWIG_fail;
42975 swig_obj[0] = args;
42976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42977 if (!SWIG_IsOK(res1)) {
42978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42979 }
42980 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42981 {
42982 PyThreadState* __tstate = wxPyBeginAllowThreads();
42983 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42984 wxPyEndAllowThreads(__tstate);
42985 if (PyErr_Occurred()) SWIG_fail;
42986 }
42987 {
42988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42989 }
42990 return resultobj;
42991 fail:
42992 return NULL;
42993 }
42994
42995
42996 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42997 PyObject *resultobj = 0;
42998 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42999 void *argp1 = 0 ;
43000 int res1 = 0 ;
43001 PyObject *swig_obj[1] ;
43002
43003 if (!args) SWIG_fail;
43004 swig_obj[0] = args;
43005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43006 if (!SWIG_IsOK(res1)) {
43007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43008 }
43009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43010 {
43011 PyThreadState* __tstate = wxPyBeginAllowThreads();
43012 (arg1)->Toggle();
43013 wxPyEndAllowThreads(__tstate);
43014 if (PyErr_Occurred()) SWIG_fail;
43015 }
43016 resultobj = SWIG_Py_Void();
43017 return resultobj;
43018 fail:
43019 return NULL;
43020 }
43021
43022
43023 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43024 PyObject *resultobj = 0;
43025 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43026 wxString *arg2 = 0 ;
43027 void *argp1 = 0 ;
43028 int res1 = 0 ;
43029 bool temp2 = false ;
43030 PyObject * obj0 = 0 ;
43031 PyObject * obj1 = 0 ;
43032 char * kwnames[] = {
43033 (char *) "self",(char *) "str", NULL
43034 };
43035
43036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43038 if (!SWIG_IsOK(res1)) {
43039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43040 }
43041 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43042 {
43043 arg2 = wxString_in_helper(obj1);
43044 if (arg2 == NULL) SWIG_fail;
43045 temp2 = true;
43046 }
43047 {
43048 PyThreadState* __tstate = wxPyBeginAllowThreads();
43049 (arg1)->SetHelp((wxString const &)*arg2);
43050 wxPyEndAllowThreads(__tstate);
43051 if (PyErr_Occurred()) SWIG_fail;
43052 }
43053 resultobj = SWIG_Py_Void();
43054 {
43055 if (temp2)
43056 delete arg2;
43057 }
43058 return resultobj;
43059 fail:
43060 {
43061 if (temp2)
43062 delete arg2;
43063 }
43064 return NULL;
43065 }
43066
43067
43068 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43069 PyObject *resultobj = 0;
43070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43071 wxString *result = 0 ;
43072 void *argp1 = 0 ;
43073 int res1 = 0 ;
43074 PyObject *swig_obj[1] ;
43075
43076 if (!args) SWIG_fail;
43077 swig_obj[0] = args;
43078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43079 if (!SWIG_IsOK(res1)) {
43080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43081 }
43082 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43083 {
43084 PyThreadState* __tstate = wxPyBeginAllowThreads();
43085 {
43086 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43087 result = (wxString *) &_result_ref;
43088 }
43089 wxPyEndAllowThreads(__tstate);
43090 if (PyErr_Occurred()) SWIG_fail;
43091 }
43092 {
43093 #if wxUSE_UNICODE
43094 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43095 #else
43096 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43097 #endif
43098 }
43099 return resultobj;
43100 fail:
43101 return NULL;
43102 }
43103
43104
43105 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43106 PyObject *resultobj = 0;
43107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43108 wxAcceleratorEntry *result = 0 ;
43109 void *argp1 = 0 ;
43110 int res1 = 0 ;
43111 PyObject *swig_obj[1] ;
43112
43113 if (!args) SWIG_fail;
43114 swig_obj[0] = args;
43115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43116 if (!SWIG_IsOK(res1)) {
43117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43118 }
43119 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43120 {
43121 PyThreadState* __tstate = wxPyBeginAllowThreads();
43122 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43123 wxPyEndAllowThreads(__tstate);
43124 if (PyErr_Occurred()) SWIG_fail;
43125 }
43126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43127 return resultobj;
43128 fail:
43129 return NULL;
43130 }
43131
43132
43133 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43134 PyObject *resultobj = 0;
43135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43136 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43137 void *argp1 = 0 ;
43138 int res1 = 0 ;
43139 void *argp2 = 0 ;
43140 int res2 = 0 ;
43141 PyObject * obj0 = 0 ;
43142 PyObject * obj1 = 0 ;
43143 char * kwnames[] = {
43144 (char *) "self",(char *) "accel", NULL
43145 };
43146
43147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43149 if (!SWIG_IsOK(res1)) {
43150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43151 }
43152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43154 if (!SWIG_IsOK(res2)) {
43155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43156 }
43157 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43158 {
43159 PyThreadState* __tstate = wxPyBeginAllowThreads();
43160 (arg1)->SetAccel(arg2);
43161 wxPyEndAllowThreads(__tstate);
43162 if (PyErr_Occurred()) SWIG_fail;
43163 }
43164 resultobj = SWIG_Py_Void();
43165 return resultobj;
43166 fail:
43167 return NULL;
43168 }
43169
43170
43171 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43172 PyObject *resultobj = 0;
43173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43174 wxBitmap *arg2 = 0 ;
43175 void *argp1 = 0 ;
43176 int res1 = 0 ;
43177 void *argp2 = 0 ;
43178 int res2 = 0 ;
43179 PyObject * obj0 = 0 ;
43180 PyObject * obj1 = 0 ;
43181 char * kwnames[] = {
43182 (char *) "self",(char *) "bitmap", NULL
43183 };
43184
43185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43187 if (!SWIG_IsOK(res1)) {
43188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43189 }
43190 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43191 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43192 if (!SWIG_IsOK(res2)) {
43193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43194 }
43195 if (!argp2) {
43196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43197 }
43198 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43199 {
43200 PyThreadState* __tstate = wxPyBeginAllowThreads();
43201 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43202 wxPyEndAllowThreads(__tstate);
43203 if (PyErr_Occurred()) SWIG_fail;
43204 }
43205 resultobj = SWIG_Py_Void();
43206 return resultobj;
43207 fail:
43208 return NULL;
43209 }
43210
43211
43212 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43213 PyObject *resultobj = 0;
43214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43215 wxBitmap *result = 0 ;
43216 void *argp1 = 0 ;
43217 int res1 = 0 ;
43218 PyObject *swig_obj[1] ;
43219
43220 if (!args) SWIG_fail;
43221 swig_obj[0] = args;
43222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43223 if (!SWIG_IsOK(res1)) {
43224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43225 }
43226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43227 {
43228 PyThreadState* __tstate = wxPyBeginAllowThreads();
43229 {
43230 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43231 result = (wxBitmap *) &_result_ref;
43232 }
43233 wxPyEndAllowThreads(__tstate);
43234 if (PyErr_Occurred()) SWIG_fail;
43235 }
43236 {
43237 wxBitmap* resultptr = new wxBitmap(*result);
43238 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43239 }
43240 return resultobj;
43241 fail:
43242 return NULL;
43243 }
43244
43245
43246 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43247 PyObject *resultobj = 0;
43248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43249 wxFont *arg2 = 0 ;
43250 void *argp1 = 0 ;
43251 int res1 = 0 ;
43252 void *argp2 = 0 ;
43253 int res2 = 0 ;
43254 PyObject * obj0 = 0 ;
43255 PyObject * obj1 = 0 ;
43256 char * kwnames[] = {
43257 (char *) "self",(char *) "font", NULL
43258 };
43259
43260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43262 if (!SWIG_IsOK(res1)) {
43263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43264 }
43265 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43266 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43267 if (!SWIG_IsOK(res2)) {
43268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43269 }
43270 if (!argp2) {
43271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43272 }
43273 arg2 = reinterpret_cast< wxFont * >(argp2);
43274 {
43275 PyThreadState* __tstate = wxPyBeginAllowThreads();
43276 (arg1)->SetFont((wxFont const &)*arg2);
43277 wxPyEndAllowThreads(__tstate);
43278 if (PyErr_Occurred()) SWIG_fail;
43279 }
43280 resultobj = SWIG_Py_Void();
43281 return resultobj;
43282 fail:
43283 return NULL;
43284 }
43285
43286
43287 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43288 PyObject *resultobj = 0;
43289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43290 wxFont result;
43291 void *argp1 = 0 ;
43292 int res1 = 0 ;
43293 PyObject *swig_obj[1] ;
43294
43295 if (!args) SWIG_fail;
43296 swig_obj[0] = args;
43297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43298 if (!SWIG_IsOK(res1)) {
43299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43300 }
43301 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43302 {
43303 PyThreadState* __tstate = wxPyBeginAllowThreads();
43304 result = (arg1)->GetFont();
43305 wxPyEndAllowThreads(__tstate);
43306 if (PyErr_Occurred()) SWIG_fail;
43307 }
43308 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43309 return resultobj;
43310 fail:
43311 return NULL;
43312 }
43313
43314
43315 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43316 PyObject *resultobj = 0;
43317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43318 wxColour *arg2 = 0 ;
43319 void *argp1 = 0 ;
43320 int res1 = 0 ;
43321 wxColour temp2 ;
43322 PyObject * obj0 = 0 ;
43323 PyObject * obj1 = 0 ;
43324 char * kwnames[] = {
43325 (char *) "self",(char *) "colText", NULL
43326 };
43327
43328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43330 if (!SWIG_IsOK(res1)) {
43331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43332 }
43333 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43334 {
43335 arg2 = &temp2;
43336 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43337 }
43338 {
43339 PyThreadState* __tstate = wxPyBeginAllowThreads();
43340 (arg1)->SetTextColour((wxColour const &)*arg2);
43341 wxPyEndAllowThreads(__tstate);
43342 if (PyErr_Occurred()) SWIG_fail;
43343 }
43344 resultobj = SWIG_Py_Void();
43345 return resultobj;
43346 fail:
43347 return NULL;
43348 }
43349
43350
43351 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43352 PyObject *resultobj = 0;
43353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43354 wxColour result;
43355 void *argp1 = 0 ;
43356 int res1 = 0 ;
43357 PyObject *swig_obj[1] ;
43358
43359 if (!args) SWIG_fail;
43360 swig_obj[0] = args;
43361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43362 if (!SWIG_IsOK(res1)) {
43363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43364 }
43365 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43366 {
43367 PyThreadState* __tstate = wxPyBeginAllowThreads();
43368 result = (arg1)->GetTextColour();
43369 wxPyEndAllowThreads(__tstate);
43370 if (PyErr_Occurred()) SWIG_fail;
43371 }
43372 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43373 return resultobj;
43374 fail:
43375 return NULL;
43376 }
43377
43378
43379 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43380 PyObject *resultobj = 0;
43381 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43382 wxColour *arg2 = 0 ;
43383 void *argp1 = 0 ;
43384 int res1 = 0 ;
43385 wxColour temp2 ;
43386 PyObject * obj0 = 0 ;
43387 PyObject * obj1 = 0 ;
43388 char * kwnames[] = {
43389 (char *) "self",(char *) "colBack", NULL
43390 };
43391
43392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43394 if (!SWIG_IsOK(res1)) {
43395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43396 }
43397 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43398 {
43399 arg2 = &temp2;
43400 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43401 }
43402 {
43403 PyThreadState* __tstate = wxPyBeginAllowThreads();
43404 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43405 wxPyEndAllowThreads(__tstate);
43406 if (PyErr_Occurred()) SWIG_fail;
43407 }
43408 resultobj = SWIG_Py_Void();
43409 return resultobj;
43410 fail:
43411 return NULL;
43412 }
43413
43414
43415 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43416 PyObject *resultobj = 0;
43417 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43418 wxColour result;
43419 void *argp1 = 0 ;
43420 int res1 = 0 ;
43421 PyObject *swig_obj[1] ;
43422
43423 if (!args) SWIG_fail;
43424 swig_obj[0] = args;
43425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43426 if (!SWIG_IsOK(res1)) {
43427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43428 }
43429 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43430 {
43431 PyThreadState* __tstate = wxPyBeginAllowThreads();
43432 result = (arg1)->GetBackgroundColour();
43433 wxPyEndAllowThreads(__tstate);
43434 if (PyErr_Occurred()) SWIG_fail;
43435 }
43436 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43437 return resultobj;
43438 fail:
43439 return NULL;
43440 }
43441
43442
43443 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43444 PyObject *resultobj = 0;
43445 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43446 wxBitmap *arg2 = 0 ;
43447 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43448 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43449 void *argp1 = 0 ;
43450 int res1 = 0 ;
43451 void *argp2 = 0 ;
43452 int res2 = 0 ;
43453 void *argp3 = 0 ;
43454 int res3 = 0 ;
43455 PyObject * obj0 = 0 ;
43456 PyObject * obj1 = 0 ;
43457 PyObject * obj2 = 0 ;
43458 char * kwnames[] = {
43459 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43460 };
43461
43462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43464 if (!SWIG_IsOK(res1)) {
43465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43466 }
43467 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43468 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43469 if (!SWIG_IsOK(res2)) {
43470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43471 }
43472 if (!argp2) {
43473 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43474 }
43475 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43476 if (obj2) {
43477 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43478 if (!SWIG_IsOK(res3)) {
43479 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43480 }
43481 if (!argp3) {
43482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43483 }
43484 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43485 }
43486 {
43487 PyThreadState* __tstate = wxPyBeginAllowThreads();
43488 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43489 wxPyEndAllowThreads(__tstate);
43490 if (PyErr_Occurred()) SWIG_fail;
43491 }
43492 resultobj = SWIG_Py_Void();
43493 return resultobj;
43494 fail:
43495 return NULL;
43496 }
43497
43498
43499 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43500 PyObject *resultobj = 0;
43501 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43502 wxBitmap *arg2 = 0 ;
43503 void *argp1 = 0 ;
43504 int res1 = 0 ;
43505 void *argp2 = 0 ;
43506 int res2 = 0 ;
43507 PyObject * obj0 = 0 ;
43508 PyObject * obj1 = 0 ;
43509 char * kwnames[] = {
43510 (char *) "self",(char *) "bmpDisabled", NULL
43511 };
43512
43513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43515 if (!SWIG_IsOK(res1)) {
43516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43517 }
43518 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43519 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43520 if (!SWIG_IsOK(res2)) {
43521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43522 }
43523 if (!argp2) {
43524 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43525 }
43526 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43527 {
43528 PyThreadState* __tstate = wxPyBeginAllowThreads();
43529 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43530 wxPyEndAllowThreads(__tstate);
43531 if (PyErr_Occurred()) SWIG_fail;
43532 }
43533 resultobj = SWIG_Py_Void();
43534 return resultobj;
43535 fail:
43536 return NULL;
43537 }
43538
43539
43540 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43541 PyObject *resultobj = 0;
43542 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43543 wxBitmap *result = 0 ;
43544 void *argp1 = 0 ;
43545 int res1 = 0 ;
43546 PyObject *swig_obj[1] ;
43547
43548 if (!args) SWIG_fail;
43549 swig_obj[0] = args;
43550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43551 if (!SWIG_IsOK(res1)) {
43552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43553 }
43554 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43555 {
43556 PyThreadState* __tstate = wxPyBeginAllowThreads();
43557 {
43558 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43559 result = (wxBitmap *) &_result_ref;
43560 }
43561 wxPyEndAllowThreads(__tstate);
43562 if (PyErr_Occurred()) SWIG_fail;
43563 }
43564 {
43565 wxBitmap* resultptr = new wxBitmap(*result);
43566 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43567 }
43568 return resultobj;
43569 fail:
43570 return NULL;
43571 }
43572
43573
43574 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43575 PyObject *resultobj = 0;
43576 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43577 int arg2 ;
43578 void *argp1 = 0 ;
43579 int res1 = 0 ;
43580 int val2 ;
43581 int ecode2 = 0 ;
43582 PyObject * obj0 = 0 ;
43583 PyObject * obj1 = 0 ;
43584 char * kwnames[] = {
43585 (char *) "self",(char *) "nWidth", NULL
43586 };
43587
43588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43590 if (!SWIG_IsOK(res1)) {
43591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43592 }
43593 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43594 ecode2 = SWIG_AsVal_int(obj1, &val2);
43595 if (!SWIG_IsOK(ecode2)) {
43596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43597 }
43598 arg2 = static_cast< int >(val2);
43599 {
43600 PyThreadState* __tstate = wxPyBeginAllowThreads();
43601 (arg1)->SetMarginWidth(arg2);
43602 wxPyEndAllowThreads(__tstate);
43603 if (PyErr_Occurred()) SWIG_fail;
43604 }
43605 resultobj = SWIG_Py_Void();
43606 return resultobj;
43607 fail:
43608 return NULL;
43609 }
43610
43611
43612 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43613 PyObject *resultobj = 0;
43614 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43615 int result;
43616 void *argp1 = 0 ;
43617 int res1 = 0 ;
43618 PyObject *swig_obj[1] ;
43619
43620 if (!args) SWIG_fail;
43621 swig_obj[0] = args;
43622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43623 if (!SWIG_IsOK(res1)) {
43624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43625 }
43626 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43627 {
43628 PyThreadState* __tstate = wxPyBeginAllowThreads();
43629 result = (int)(arg1)->GetMarginWidth();
43630 wxPyEndAllowThreads(__tstate);
43631 if (PyErr_Occurred()) SWIG_fail;
43632 }
43633 resultobj = SWIG_From_int(static_cast< int >(result));
43634 return resultobj;
43635 fail:
43636 return NULL;
43637 }
43638
43639
43640 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43641 PyObject *resultobj = 0;
43642 int result;
43643
43644 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43645 {
43646 PyThreadState* __tstate = wxPyBeginAllowThreads();
43647 result = (int)wxMenuItem::GetDefaultMarginWidth();
43648 wxPyEndAllowThreads(__tstate);
43649 if (PyErr_Occurred()) SWIG_fail;
43650 }
43651 resultobj = SWIG_From_int(static_cast< int >(result));
43652 return resultobj;
43653 fail:
43654 return NULL;
43655 }
43656
43657
43658 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43659 PyObject *resultobj = 0;
43660 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43661 bool result;
43662 void *argp1 = 0 ;
43663 int res1 = 0 ;
43664 PyObject *swig_obj[1] ;
43665
43666 if (!args) SWIG_fail;
43667 swig_obj[0] = args;
43668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43669 if (!SWIG_IsOK(res1)) {
43670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43671 }
43672 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43673 {
43674 PyThreadState* __tstate = wxPyBeginAllowThreads();
43675 result = (bool)(arg1)->IsOwnerDrawn();
43676 wxPyEndAllowThreads(__tstate);
43677 if (PyErr_Occurred()) SWIG_fail;
43678 }
43679 {
43680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43681 }
43682 return resultobj;
43683 fail:
43684 return NULL;
43685 }
43686
43687
43688 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43689 PyObject *resultobj = 0;
43690 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43691 bool arg2 = (bool) true ;
43692 void *argp1 = 0 ;
43693 int res1 = 0 ;
43694 bool val2 ;
43695 int ecode2 = 0 ;
43696 PyObject * obj0 = 0 ;
43697 PyObject * obj1 = 0 ;
43698 char * kwnames[] = {
43699 (char *) "self",(char *) "ownerDrawn", NULL
43700 };
43701
43702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43704 if (!SWIG_IsOK(res1)) {
43705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43706 }
43707 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43708 if (obj1) {
43709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43710 if (!SWIG_IsOK(ecode2)) {
43711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43712 }
43713 arg2 = static_cast< bool >(val2);
43714 }
43715 {
43716 PyThreadState* __tstate = wxPyBeginAllowThreads();
43717 (arg1)->SetOwnerDrawn(arg2);
43718 wxPyEndAllowThreads(__tstate);
43719 if (PyErr_Occurred()) SWIG_fail;
43720 }
43721 resultobj = SWIG_Py_Void();
43722 return resultobj;
43723 fail:
43724 return NULL;
43725 }
43726
43727
43728 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43729 PyObject *resultobj = 0;
43730 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43731 void *argp1 = 0 ;
43732 int res1 = 0 ;
43733 PyObject *swig_obj[1] ;
43734
43735 if (!args) SWIG_fail;
43736 swig_obj[0] = args;
43737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43738 if (!SWIG_IsOK(res1)) {
43739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43740 }
43741 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43742 {
43743 PyThreadState* __tstate = wxPyBeginAllowThreads();
43744 (arg1)->ResetOwnerDrawn();
43745 wxPyEndAllowThreads(__tstate);
43746 if (PyErr_Occurred()) SWIG_fail;
43747 }
43748 resultobj = SWIG_Py_Void();
43749 return resultobj;
43750 fail:
43751 return NULL;
43752 }
43753
43754
43755 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43756 PyObject *obj;
43757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43758 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43759 return SWIG_Py_Void();
43760 }
43761
43762 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43763 return SWIG_Python_InitShadowInstance(args);
43764 }
43765
43766 SWIGINTERN int ControlNameStr_set(PyObject *) {
43767 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43768 return 1;
43769 }
43770
43771
43772 SWIGINTERN PyObject *ControlNameStr_get(void) {
43773 PyObject *pyobj = 0;
43774
43775 {
43776 #if wxUSE_UNICODE
43777 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43778 #else
43779 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43780 #endif
43781 }
43782 return pyobj;
43783 }
43784
43785
43786 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43787 PyObject *resultobj = 0;
43788 wxWindow *arg1 = (wxWindow *) 0 ;
43789 int arg2 = (int) -1 ;
43790 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43791 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43792 wxSize const &arg4_defvalue = wxDefaultSize ;
43793 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43794 long arg5 = (long) 0 ;
43795 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43796 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43797 wxString const &arg7_defvalue = wxPyControlNameStr ;
43798 wxString *arg7 = (wxString *) &arg7_defvalue ;
43799 wxControl *result = 0 ;
43800 void *argp1 = 0 ;
43801 int res1 = 0 ;
43802 int val2 ;
43803 int ecode2 = 0 ;
43804 wxPoint temp3 ;
43805 wxSize temp4 ;
43806 long val5 ;
43807 int ecode5 = 0 ;
43808 void *argp6 = 0 ;
43809 int res6 = 0 ;
43810 bool temp7 = false ;
43811 PyObject * obj0 = 0 ;
43812 PyObject * obj1 = 0 ;
43813 PyObject * obj2 = 0 ;
43814 PyObject * obj3 = 0 ;
43815 PyObject * obj4 = 0 ;
43816 PyObject * obj5 = 0 ;
43817 PyObject * obj6 = 0 ;
43818 char * kwnames[] = {
43819 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43820 };
43821
43822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43824 if (!SWIG_IsOK(res1)) {
43825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43826 }
43827 arg1 = reinterpret_cast< wxWindow * >(argp1);
43828 if (obj1) {
43829 ecode2 = SWIG_AsVal_int(obj1, &val2);
43830 if (!SWIG_IsOK(ecode2)) {
43831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43832 }
43833 arg2 = static_cast< int >(val2);
43834 }
43835 if (obj2) {
43836 {
43837 arg3 = &temp3;
43838 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43839 }
43840 }
43841 if (obj3) {
43842 {
43843 arg4 = &temp4;
43844 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43845 }
43846 }
43847 if (obj4) {
43848 ecode5 = SWIG_AsVal_long(obj4, &val5);
43849 if (!SWIG_IsOK(ecode5)) {
43850 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43851 }
43852 arg5 = static_cast< long >(val5);
43853 }
43854 if (obj5) {
43855 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43856 if (!SWIG_IsOK(res6)) {
43857 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43858 }
43859 if (!argp6) {
43860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43861 }
43862 arg6 = reinterpret_cast< wxValidator * >(argp6);
43863 }
43864 if (obj6) {
43865 {
43866 arg7 = wxString_in_helper(obj6);
43867 if (arg7 == NULL) SWIG_fail;
43868 temp7 = true;
43869 }
43870 }
43871 {
43872 if (!wxPyCheckForApp()) SWIG_fail;
43873 PyThreadState* __tstate = wxPyBeginAllowThreads();
43874 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43875 wxPyEndAllowThreads(__tstate);
43876 if (PyErr_Occurred()) SWIG_fail;
43877 }
43878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43879 {
43880 if (temp7)
43881 delete arg7;
43882 }
43883 return resultobj;
43884 fail:
43885 {
43886 if (temp7)
43887 delete arg7;
43888 }
43889 return NULL;
43890 }
43891
43892
43893 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43894 PyObject *resultobj = 0;
43895 wxControl *result = 0 ;
43896
43897 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43898 {
43899 if (!wxPyCheckForApp()) SWIG_fail;
43900 PyThreadState* __tstate = wxPyBeginAllowThreads();
43901 result = (wxControl *)new wxControl();
43902 wxPyEndAllowThreads(__tstate);
43903 if (PyErr_Occurred()) SWIG_fail;
43904 }
43905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43906 return resultobj;
43907 fail:
43908 return NULL;
43909 }
43910
43911
43912 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43913 PyObject *resultobj = 0;
43914 wxControl *arg1 = (wxControl *) 0 ;
43915 wxWindow *arg2 = (wxWindow *) 0 ;
43916 int arg3 = (int) -1 ;
43917 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43918 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43919 wxSize const &arg5_defvalue = wxDefaultSize ;
43920 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43921 long arg6 = (long) 0 ;
43922 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43923 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43924 wxString const &arg8_defvalue = wxPyControlNameStr ;
43925 wxString *arg8 = (wxString *) &arg8_defvalue ;
43926 bool result;
43927 void *argp1 = 0 ;
43928 int res1 = 0 ;
43929 void *argp2 = 0 ;
43930 int res2 = 0 ;
43931 int val3 ;
43932 int ecode3 = 0 ;
43933 wxPoint temp4 ;
43934 wxSize temp5 ;
43935 long val6 ;
43936 int ecode6 = 0 ;
43937 void *argp7 = 0 ;
43938 int res7 = 0 ;
43939 bool temp8 = false ;
43940 PyObject * obj0 = 0 ;
43941 PyObject * obj1 = 0 ;
43942 PyObject * obj2 = 0 ;
43943 PyObject * obj3 = 0 ;
43944 PyObject * obj4 = 0 ;
43945 PyObject * obj5 = 0 ;
43946 PyObject * obj6 = 0 ;
43947 PyObject * obj7 = 0 ;
43948 char * kwnames[] = {
43949 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43950 };
43951
43952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43954 if (!SWIG_IsOK(res1)) {
43955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43956 }
43957 arg1 = reinterpret_cast< wxControl * >(argp1);
43958 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43959 if (!SWIG_IsOK(res2)) {
43960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43961 }
43962 arg2 = reinterpret_cast< wxWindow * >(argp2);
43963 if (obj2) {
43964 ecode3 = SWIG_AsVal_int(obj2, &val3);
43965 if (!SWIG_IsOK(ecode3)) {
43966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43967 }
43968 arg3 = static_cast< int >(val3);
43969 }
43970 if (obj3) {
43971 {
43972 arg4 = &temp4;
43973 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43974 }
43975 }
43976 if (obj4) {
43977 {
43978 arg5 = &temp5;
43979 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43980 }
43981 }
43982 if (obj5) {
43983 ecode6 = SWIG_AsVal_long(obj5, &val6);
43984 if (!SWIG_IsOK(ecode6)) {
43985 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43986 }
43987 arg6 = static_cast< long >(val6);
43988 }
43989 if (obj6) {
43990 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43991 if (!SWIG_IsOK(res7)) {
43992 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43993 }
43994 if (!argp7) {
43995 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43996 }
43997 arg7 = reinterpret_cast< wxValidator * >(argp7);
43998 }
43999 if (obj7) {
44000 {
44001 arg8 = wxString_in_helper(obj7);
44002 if (arg8 == NULL) SWIG_fail;
44003 temp8 = true;
44004 }
44005 }
44006 {
44007 PyThreadState* __tstate = wxPyBeginAllowThreads();
44008 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44009 wxPyEndAllowThreads(__tstate);
44010 if (PyErr_Occurred()) SWIG_fail;
44011 }
44012 {
44013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44014 }
44015 {
44016 if (temp8)
44017 delete arg8;
44018 }
44019 return resultobj;
44020 fail:
44021 {
44022 if (temp8)
44023 delete arg8;
44024 }
44025 return NULL;
44026 }
44027
44028
44029 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44030 PyObject *resultobj = 0;
44031 wxControl *arg1 = (wxControl *) 0 ;
44032 wxCommandEvent *arg2 = 0 ;
44033 void *argp1 = 0 ;
44034 int res1 = 0 ;
44035 void *argp2 = 0 ;
44036 int res2 = 0 ;
44037 PyObject * obj0 = 0 ;
44038 PyObject * obj1 = 0 ;
44039 char * kwnames[] = {
44040 (char *) "self",(char *) "event", NULL
44041 };
44042
44043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44045 if (!SWIG_IsOK(res1)) {
44046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44047 }
44048 arg1 = reinterpret_cast< wxControl * >(argp1);
44049 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44050 if (!SWIG_IsOK(res2)) {
44051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44052 }
44053 if (!argp2) {
44054 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44055 }
44056 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44057 {
44058 PyThreadState* __tstate = wxPyBeginAllowThreads();
44059 (arg1)->Command(*arg2);
44060 wxPyEndAllowThreads(__tstate);
44061 if (PyErr_Occurred()) SWIG_fail;
44062 }
44063 resultobj = SWIG_Py_Void();
44064 return resultobj;
44065 fail:
44066 return NULL;
44067 }
44068
44069
44070 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44071 PyObject *resultobj = 0;
44072 wxControl *arg1 = (wxControl *) 0 ;
44073 wxString result;
44074 void *argp1 = 0 ;
44075 int res1 = 0 ;
44076 PyObject *swig_obj[1] ;
44077
44078 if (!args) SWIG_fail;
44079 swig_obj[0] = args;
44080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44081 if (!SWIG_IsOK(res1)) {
44082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44083 }
44084 arg1 = reinterpret_cast< wxControl * >(argp1);
44085 {
44086 PyThreadState* __tstate = wxPyBeginAllowThreads();
44087 result = (arg1)->GetLabel();
44088 wxPyEndAllowThreads(__tstate);
44089 if (PyErr_Occurred()) SWIG_fail;
44090 }
44091 {
44092 #if wxUSE_UNICODE
44093 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44094 #else
44095 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44096 #endif
44097 }
44098 return resultobj;
44099 fail:
44100 return NULL;
44101 }
44102
44103
44104 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44105 PyObject *resultobj = 0;
44106 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44107 SwigValueWrapper<wxVisualAttributes > result;
44108 int val1 ;
44109 int ecode1 = 0 ;
44110 PyObject * obj0 = 0 ;
44111 char * kwnames[] = {
44112 (char *) "variant", NULL
44113 };
44114
44115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44116 if (obj0) {
44117 ecode1 = SWIG_AsVal_int(obj0, &val1);
44118 if (!SWIG_IsOK(ecode1)) {
44119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44120 }
44121 arg1 = static_cast< wxWindowVariant >(val1);
44122 }
44123 {
44124 if (!wxPyCheckForApp()) SWIG_fail;
44125 PyThreadState* __tstate = wxPyBeginAllowThreads();
44126 result = wxControl::GetClassDefaultAttributes(arg1);
44127 wxPyEndAllowThreads(__tstate);
44128 if (PyErr_Occurred()) SWIG_fail;
44129 }
44130 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44131 return resultobj;
44132 fail:
44133 return NULL;
44134 }
44135
44136
44137 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44138 PyObject *obj;
44139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44140 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44141 return SWIG_Py_Void();
44142 }
44143
44144 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44145 return SWIG_Python_InitShadowInstance(args);
44146 }
44147
44148 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44149 PyObject *resultobj = 0;
44150 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44151 wxString *arg2 = 0 ;
44152 PyObject *arg3 = (PyObject *) NULL ;
44153 int result;
44154 void *argp1 = 0 ;
44155 int res1 = 0 ;
44156 bool temp2 = false ;
44157 PyObject * obj0 = 0 ;
44158 PyObject * obj1 = 0 ;
44159 PyObject * obj2 = 0 ;
44160 char * kwnames[] = {
44161 (char *) "self",(char *) "item",(char *) "clientData", NULL
44162 };
44163
44164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44166 if (!SWIG_IsOK(res1)) {
44167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44168 }
44169 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44170 {
44171 arg2 = wxString_in_helper(obj1);
44172 if (arg2 == NULL) SWIG_fail;
44173 temp2 = true;
44174 }
44175 if (obj2) {
44176 arg3 = obj2;
44177 }
44178 {
44179 PyThreadState* __tstate = wxPyBeginAllowThreads();
44180 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44181 wxPyEndAllowThreads(__tstate);
44182 if (PyErr_Occurred()) SWIG_fail;
44183 }
44184 resultobj = SWIG_From_int(static_cast< int >(result));
44185 {
44186 if (temp2)
44187 delete arg2;
44188 }
44189 return resultobj;
44190 fail:
44191 {
44192 if (temp2)
44193 delete arg2;
44194 }
44195 return NULL;
44196 }
44197
44198
44199 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44200 PyObject *resultobj = 0;
44201 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44202 wxArrayString *arg2 = 0 ;
44203 void *argp1 = 0 ;
44204 int res1 = 0 ;
44205 bool temp2 = false ;
44206 PyObject * obj0 = 0 ;
44207 PyObject * obj1 = 0 ;
44208 char * kwnames[] = {
44209 (char *) "self",(char *) "strings", NULL
44210 };
44211
44212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44214 if (!SWIG_IsOK(res1)) {
44215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44216 }
44217 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44218 {
44219 if (! PySequence_Check(obj1)) {
44220 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44221 SWIG_fail;
44222 }
44223 arg2 = new wxArrayString;
44224 temp2 = true;
44225 int i, len=PySequence_Length(obj1);
44226 for (i=0; i<len; i++) {
44227 PyObject* item = PySequence_GetItem(obj1, i);
44228 wxString* s = wxString_in_helper(item);
44229 if (PyErr_Occurred()) SWIG_fail;
44230 arg2->Add(*s);
44231 delete s;
44232 Py_DECREF(item);
44233 }
44234 }
44235 {
44236 PyThreadState* __tstate = wxPyBeginAllowThreads();
44237 (arg1)->Append((wxArrayString const &)*arg2);
44238 wxPyEndAllowThreads(__tstate);
44239 if (PyErr_Occurred()) SWIG_fail;
44240 }
44241 resultobj = SWIG_Py_Void();
44242 {
44243 if (temp2) delete arg2;
44244 }
44245 return resultobj;
44246 fail:
44247 {
44248 if (temp2) delete arg2;
44249 }
44250 return NULL;
44251 }
44252
44253
44254 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44255 PyObject *resultobj = 0;
44256 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44257 wxString *arg2 = 0 ;
44258 unsigned int arg3 ;
44259 PyObject *arg4 = (PyObject *) NULL ;
44260 int result;
44261 void *argp1 = 0 ;
44262 int res1 = 0 ;
44263 bool temp2 = false ;
44264 unsigned int val3 ;
44265 int ecode3 = 0 ;
44266 PyObject * obj0 = 0 ;
44267 PyObject * obj1 = 0 ;
44268 PyObject * obj2 = 0 ;
44269 PyObject * obj3 = 0 ;
44270 char * kwnames[] = {
44271 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44272 };
44273
44274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44276 if (!SWIG_IsOK(res1)) {
44277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44278 }
44279 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44280 {
44281 arg2 = wxString_in_helper(obj1);
44282 if (arg2 == NULL) SWIG_fail;
44283 temp2 = true;
44284 }
44285 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44286 if (!SWIG_IsOK(ecode3)) {
44287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44288 }
44289 arg3 = static_cast< unsigned int >(val3);
44290 if (obj3) {
44291 arg4 = obj3;
44292 }
44293 {
44294 PyThreadState* __tstate = wxPyBeginAllowThreads();
44295 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44296 wxPyEndAllowThreads(__tstate);
44297 if (PyErr_Occurred()) SWIG_fail;
44298 }
44299 resultobj = SWIG_From_int(static_cast< int >(result));
44300 {
44301 if (temp2)
44302 delete arg2;
44303 }
44304 return resultobj;
44305 fail:
44306 {
44307 if (temp2)
44308 delete arg2;
44309 }
44310 return NULL;
44311 }
44312
44313
44314 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44315 PyObject *resultobj = 0;
44316 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44317 void *argp1 = 0 ;
44318 int res1 = 0 ;
44319 PyObject *swig_obj[1] ;
44320
44321 if (!args) SWIG_fail;
44322 swig_obj[0] = args;
44323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44324 if (!SWIG_IsOK(res1)) {
44325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44326 }
44327 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44328 {
44329 PyThreadState* __tstate = wxPyBeginAllowThreads();
44330 (arg1)->Clear();
44331 wxPyEndAllowThreads(__tstate);
44332 if (PyErr_Occurred()) SWIG_fail;
44333 }
44334 resultobj = SWIG_Py_Void();
44335 return resultobj;
44336 fail:
44337 return NULL;
44338 }
44339
44340
44341 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44342 PyObject *resultobj = 0;
44343 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44344 unsigned int arg2 ;
44345 void *argp1 = 0 ;
44346 int res1 = 0 ;
44347 unsigned int val2 ;
44348 int ecode2 = 0 ;
44349 PyObject * obj0 = 0 ;
44350 PyObject * obj1 = 0 ;
44351 char * kwnames[] = {
44352 (char *) "self",(char *) "n", NULL
44353 };
44354
44355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44357 if (!SWIG_IsOK(res1)) {
44358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44359 }
44360 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44361 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44362 if (!SWIG_IsOK(ecode2)) {
44363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44364 }
44365 arg2 = static_cast< unsigned int >(val2);
44366 {
44367 PyThreadState* __tstate = wxPyBeginAllowThreads();
44368 (arg1)->Delete(arg2);
44369 wxPyEndAllowThreads(__tstate);
44370 if (PyErr_Occurred()) SWIG_fail;
44371 }
44372 resultobj = SWIG_Py_Void();
44373 return resultobj;
44374 fail:
44375 return NULL;
44376 }
44377
44378
44379 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44380 PyObject *resultobj = 0;
44381 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44382 unsigned int arg2 ;
44383 PyObject *result = 0 ;
44384 void *argp1 = 0 ;
44385 int res1 = 0 ;
44386 unsigned int val2 ;
44387 int ecode2 = 0 ;
44388 PyObject * obj0 = 0 ;
44389 PyObject * obj1 = 0 ;
44390 char * kwnames[] = {
44391 (char *) "self",(char *) "n", NULL
44392 };
44393
44394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44396 if (!SWIG_IsOK(res1)) {
44397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44398 }
44399 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44400 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44401 if (!SWIG_IsOK(ecode2)) {
44402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44403 }
44404 arg2 = static_cast< unsigned int >(val2);
44405 {
44406 PyThreadState* __tstate = wxPyBeginAllowThreads();
44407 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44408 wxPyEndAllowThreads(__tstate);
44409 if (PyErr_Occurred()) SWIG_fail;
44410 }
44411 resultobj = result;
44412 return resultobj;
44413 fail:
44414 return NULL;
44415 }
44416
44417
44418 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44419 PyObject *resultobj = 0;
44420 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44421 unsigned int arg2 ;
44422 PyObject *arg3 = (PyObject *) 0 ;
44423 void *argp1 = 0 ;
44424 int res1 = 0 ;
44425 unsigned int val2 ;
44426 int ecode2 = 0 ;
44427 PyObject * obj0 = 0 ;
44428 PyObject * obj1 = 0 ;
44429 PyObject * obj2 = 0 ;
44430 char * kwnames[] = {
44431 (char *) "self",(char *) "n",(char *) "clientData", NULL
44432 };
44433
44434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44436 if (!SWIG_IsOK(res1)) {
44437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44438 }
44439 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44440 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44441 if (!SWIG_IsOK(ecode2)) {
44442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44443 }
44444 arg2 = static_cast< unsigned int >(val2);
44445 arg3 = obj2;
44446 {
44447 PyThreadState* __tstate = wxPyBeginAllowThreads();
44448 wxItemContainer_SetClientData(arg1,arg2,arg3);
44449 wxPyEndAllowThreads(__tstate);
44450 if (PyErr_Occurred()) SWIG_fail;
44451 }
44452 resultobj = SWIG_Py_Void();
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44460 PyObject *resultobj = 0;
44461 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44462 unsigned int result;
44463 void *argp1 = 0 ;
44464 int res1 = 0 ;
44465 PyObject *swig_obj[1] ;
44466
44467 if (!args) SWIG_fail;
44468 swig_obj[0] = args;
44469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44470 if (!SWIG_IsOK(res1)) {
44471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44472 }
44473 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44474 {
44475 PyThreadState* __tstate = wxPyBeginAllowThreads();
44476 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44477 wxPyEndAllowThreads(__tstate);
44478 if (PyErr_Occurred()) SWIG_fail;
44479 }
44480 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44481 return resultobj;
44482 fail:
44483 return NULL;
44484 }
44485
44486
44487 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44488 PyObject *resultobj = 0;
44489 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44490 bool result;
44491 void *argp1 = 0 ;
44492 int res1 = 0 ;
44493 PyObject *swig_obj[1] ;
44494
44495 if (!args) SWIG_fail;
44496 swig_obj[0] = args;
44497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44498 if (!SWIG_IsOK(res1)) {
44499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44500 }
44501 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44502 {
44503 PyThreadState* __tstate = wxPyBeginAllowThreads();
44504 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44505 wxPyEndAllowThreads(__tstate);
44506 if (PyErr_Occurred()) SWIG_fail;
44507 }
44508 {
44509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44510 }
44511 return resultobj;
44512 fail:
44513 return NULL;
44514 }
44515
44516
44517 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44518 PyObject *resultobj = 0;
44519 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44520 unsigned int arg2 ;
44521 wxString result;
44522 void *argp1 = 0 ;
44523 int res1 = 0 ;
44524 unsigned int val2 ;
44525 int ecode2 = 0 ;
44526 PyObject * obj0 = 0 ;
44527 PyObject * obj1 = 0 ;
44528 char * kwnames[] = {
44529 (char *) "self",(char *) "n", NULL
44530 };
44531
44532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44534 if (!SWIG_IsOK(res1)) {
44535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44536 }
44537 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44538 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44539 if (!SWIG_IsOK(ecode2)) {
44540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44541 }
44542 arg2 = static_cast< unsigned int >(val2);
44543 {
44544 PyThreadState* __tstate = wxPyBeginAllowThreads();
44545 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44546 wxPyEndAllowThreads(__tstate);
44547 if (PyErr_Occurred()) SWIG_fail;
44548 }
44549 {
44550 #if wxUSE_UNICODE
44551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44552 #else
44553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44554 #endif
44555 }
44556 return resultobj;
44557 fail:
44558 return NULL;
44559 }
44560
44561
44562 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44563 PyObject *resultobj = 0;
44564 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44565 wxArrayString result;
44566 void *argp1 = 0 ;
44567 int res1 = 0 ;
44568 PyObject *swig_obj[1] ;
44569
44570 if (!args) SWIG_fail;
44571 swig_obj[0] = args;
44572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44573 if (!SWIG_IsOK(res1)) {
44574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44575 }
44576 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44577 {
44578 PyThreadState* __tstate = wxPyBeginAllowThreads();
44579 result = ((wxItemContainer const *)arg1)->GetStrings();
44580 wxPyEndAllowThreads(__tstate);
44581 if (PyErr_Occurred()) SWIG_fail;
44582 }
44583 {
44584 resultobj = wxArrayString2PyList_helper(result);
44585 }
44586 return resultobj;
44587 fail:
44588 return NULL;
44589 }
44590
44591
44592 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44593 PyObject *resultobj = 0;
44594 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44595 unsigned int arg2 ;
44596 wxString *arg3 = 0 ;
44597 void *argp1 = 0 ;
44598 int res1 = 0 ;
44599 unsigned int val2 ;
44600 int ecode2 = 0 ;
44601 bool temp3 = false ;
44602 PyObject * obj0 = 0 ;
44603 PyObject * obj1 = 0 ;
44604 PyObject * obj2 = 0 ;
44605 char * kwnames[] = {
44606 (char *) "self",(char *) "n",(char *) "s", NULL
44607 };
44608
44609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44611 if (!SWIG_IsOK(res1)) {
44612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44613 }
44614 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44615 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44616 if (!SWIG_IsOK(ecode2)) {
44617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44618 }
44619 arg2 = static_cast< unsigned int >(val2);
44620 {
44621 arg3 = wxString_in_helper(obj2);
44622 if (arg3 == NULL) SWIG_fail;
44623 temp3 = true;
44624 }
44625 {
44626 PyThreadState* __tstate = wxPyBeginAllowThreads();
44627 (arg1)->SetString(arg2,(wxString const &)*arg3);
44628 wxPyEndAllowThreads(__tstate);
44629 if (PyErr_Occurred()) SWIG_fail;
44630 }
44631 resultobj = SWIG_Py_Void();
44632 {
44633 if (temp3)
44634 delete arg3;
44635 }
44636 return resultobj;
44637 fail:
44638 {
44639 if (temp3)
44640 delete arg3;
44641 }
44642 return NULL;
44643 }
44644
44645
44646 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44647 PyObject *resultobj = 0;
44648 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44649 wxString *arg2 = 0 ;
44650 int result;
44651 void *argp1 = 0 ;
44652 int res1 = 0 ;
44653 bool temp2 = false ;
44654 PyObject * obj0 = 0 ;
44655 PyObject * obj1 = 0 ;
44656 char * kwnames[] = {
44657 (char *) "self",(char *) "s", NULL
44658 };
44659
44660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44662 if (!SWIG_IsOK(res1)) {
44663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44664 }
44665 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44666 {
44667 arg2 = wxString_in_helper(obj1);
44668 if (arg2 == NULL) SWIG_fail;
44669 temp2 = true;
44670 }
44671 {
44672 PyThreadState* __tstate = wxPyBeginAllowThreads();
44673 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44674 wxPyEndAllowThreads(__tstate);
44675 if (PyErr_Occurred()) SWIG_fail;
44676 }
44677 resultobj = SWIG_From_int(static_cast< int >(result));
44678 {
44679 if (temp2)
44680 delete arg2;
44681 }
44682 return resultobj;
44683 fail:
44684 {
44685 if (temp2)
44686 delete arg2;
44687 }
44688 return NULL;
44689 }
44690
44691
44692 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44693 PyObject *resultobj = 0;
44694 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44695 int arg2 ;
44696 void *argp1 = 0 ;
44697 int res1 = 0 ;
44698 int val2 ;
44699 int ecode2 = 0 ;
44700 PyObject * obj0 = 0 ;
44701 PyObject * obj1 = 0 ;
44702 char * kwnames[] = {
44703 (char *) "self",(char *) "n", NULL
44704 };
44705
44706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44708 if (!SWIG_IsOK(res1)) {
44709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44710 }
44711 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44712 ecode2 = SWIG_AsVal_int(obj1, &val2);
44713 if (!SWIG_IsOK(ecode2)) {
44714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44715 }
44716 arg2 = static_cast< int >(val2);
44717 {
44718 PyThreadState* __tstate = wxPyBeginAllowThreads();
44719 (arg1)->SetSelection(arg2);
44720 wxPyEndAllowThreads(__tstate);
44721 if (PyErr_Occurred()) SWIG_fail;
44722 }
44723 resultobj = SWIG_Py_Void();
44724 return resultobj;
44725 fail:
44726 return NULL;
44727 }
44728
44729
44730 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44731 PyObject *resultobj = 0;
44732 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44733 int result;
44734 void *argp1 = 0 ;
44735 int res1 = 0 ;
44736 PyObject *swig_obj[1] ;
44737
44738 if (!args) SWIG_fail;
44739 swig_obj[0] = args;
44740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44741 if (!SWIG_IsOK(res1)) {
44742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44743 }
44744 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44745 {
44746 PyThreadState* __tstate = wxPyBeginAllowThreads();
44747 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44748 wxPyEndAllowThreads(__tstate);
44749 if (PyErr_Occurred()) SWIG_fail;
44750 }
44751 resultobj = SWIG_From_int(static_cast< int >(result));
44752 return resultobj;
44753 fail:
44754 return NULL;
44755 }
44756
44757
44758 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44759 PyObject *resultobj = 0;
44760 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44761 wxString *arg2 = 0 ;
44762 bool result;
44763 void *argp1 = 0 ;
44764 int res1 = 0 ;
44765 bool temp2 = false ;
44766 PyObject * obj0 = 0 ;
44767 PyObject * obj1 = 0 ;
44768 char * kwnames[] = {
44769 (char *) "self",(char *) "s", NULL
44770 };
44771
44772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44774 if (!SWIG_IsOK(res1)) {
44775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44776 }
44777 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44778 {
44779 arg2 = wxString_in_helper(obj1);
44780 if (arg2 == NULL) SWIG_fail;
44781 temp2 = true;
44782 }
44783 {
44784 PyThreadState* __tstate = wxPyBeginAllowThreads();
44785 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44786 wxPyEndAllowThreads(__tstate);
44787 if (PyErr_Occurred()) SWIG_fail;
44788 }
44789 {
44790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44791 }
44792 {
44793 if (temp2)
44794 delete arg2;
44795 }
44796 return resultobj;
44797 fail:
44798 {
44799 if (temp2)
44800 delete arg2;
44801 }
44802 return NULL;
44803 }
44804
44805
44806 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44807 PyObject *resultobj = 0;
44808 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44809 wxString result;
44810 void *argp1 = 0 ;
44811 int res1 = 0 ;
44812 PyObject *swig_obj[1] ;
44813
44814 if (!args) SWIG_fail;
44815 swig_obj[0] = args;
44816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44817 if (!SWIG_IsOK(res1)) {
44818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44819 }
44820 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44821 {
44822 PyThreadState* __tstate = wxPyBeginAllowThreads();
44823 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44824 wxPyEndAllowThreads(__tstate);
44825 if (PyErr_Occurred()) SWIG_fail;
44826 }
44827 {
44828 #if wxUSE_UNICODE
44829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44830 #else
44831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44832 #endif
44833 }
44834 return resultobj;
44835 fail:
44836 return NULL;
44837 }
44838
44839
44840 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44841 PyObject *resultobj = 0;
44842 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44843 int arg2 ;
44844 void *argp1 = 0 ;
44845 int res1 = 0 ;
44846 int val2 ;
44847 int ecode2 = 0 ;
44848 PyObject * obj0 = 0 ;
44849 PyObject * obj1 = 0 ;
44850 char * kwnames[] = {
44851 (char *) "self",(char *) "n", NULL
44852 };
44853
44854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44856 if (!SWIG_IsOK(res1)) {
44857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44858 }
44859 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44860 ecode2 = SWIG_AsVal_int(obj1, &val2);
44861 if (!SWIG_IsOK(ecode2)) {
44862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44863 }
44864 arg2 = static_cast< int >(val2);
44865 {
44866 PyThreadState* __tstate = wxPyBeginAllowThreads();
44867 (arg1)->Select(arg2);
44868 wxPyEndAllowThreads(__tstate);
44869 if (PyErr_Occurred()) SWIG_fail;
44870 }
44871 resultobj = SWIG_Py_Void();
44872 return resultobj;
44873 fail:
44874 return NULL;
44875 }
44876
44877
44878 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44879 PyObject *obj;
44880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44881 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44882 return SWIG_Py_Void();
44883 }
44884
44885 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44886 PyObject *obj;
44887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44888 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44889 return SWIG_Py_Void();
44890 }
44891
44892 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44893 PyObject *resultobj = 0;
44894 wxSizerItem *result = 0 ;
44895
44896 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44897 {
44898 PyThreadState* __tstate = wxPyBeginAllowThreads();
44899 result = (wxSizerItem *)new wxSizerItem();
44900 wxPyEndAllowThreads(__tstate);
44901 if (PyErr_Occurred()) SWIG_fail;
44902 }
44903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44904 return resultobj;
44905 fail:
44906 return NULL;
44907 }
44908
44909
44910 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44911 PyObject *resultobj = 0;
44912 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44913 void *argp1 = 0 ;
44914 int res1 = 0 ;
44915 PyObject *swig_obj[1] ;
44916
44917 if (!args) SWIG_fail;
44918 swig_obj[0] = args;
44919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44920 if (!SWIG_IsOK(res1)) {
44921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44922 }
44923 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44924 {
44925 PyThreadState* __tstate = wxPyBeginAllowThreads();
44926 delete arg1;
44927
44928 wxPyEndAllowThreads(__tstate);
44929 if (PyErr_Occurred()) SWIG_fail;
44930 }
44931 resultobj = SWIG_Py_Void();
44932 return resultobj;
44933 fail:
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44939 PyObject *resultobj = 0;
44940 wxWindow *arg1 = (wxWindow *) 0 ;
44941 int arg2 ;
44942 int arg3 ;
44943 int arg4 ;
44944 PyObject *arg5 = (PyObject *) NULL ;
44945 wxSizerItem *result = 0 ;
44946 void *argp1 = 0 ;
44947 int res1 = 0 ;
44948 int val2 ;
44949 int ecode2 = 0 ;
44950 int val3 ;
44951 int ecode3 = 0 ;
44952 int val4 ;
44953 int ecode4 = 0 ;
44954 PyObject * obj0 = 0 ;
44955 PyObject * obj1 = 0 ;
44956 PyObject * obj2 = 0 ;
44957 PyObject * obj3 = 0 ;
44958 PyObject * obj4 = 0 ;
44959 char * kwnames[] = {
44960 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44961 };
44962
44963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44965 if (!SWIG_IsOK(res1)) {
44966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44967 }
44968 arg1 = reinterpret_cast< wxWindow * >(argp1);
44969 ecode2 = SWIG_AsVal_int(obj1, &val2);
44970 if (!SWIG_IsOK(ecode2)) {
44971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44972 }
44973 arg2 = static_cast< int >(val2);
44974 ecode3 = SWIG_AsVal_int(obj2, &val3);
44975 if (!SWIG_IsOK(ecode3)) {
44976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44977 }
44978 arg3 = static_cast< int >(val3);
44979 ecode4 = SWIG_AsVal_int(obj3, &val4);
44980 if (!SWIG_IsOK(ecode4)) {
44981 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44982 }
44983 arg4 = static_cast< int >(val4);
44984 if (obj4) {
44985 arg5 = obj4;
44986 }
44987 {
44988 PyThreadState* __tstate = wxPyBeginAllowThreads();
44989 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44990 wxPyEndAllowThreads(__tstate);
44991 if (PyErr_Occurred()) SWIG_fail;
44992 }
44993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44994 return resultobj;
44995 fail:
44996 return NULL;
44997 }
44998
44999
45000 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45001 PyObject *resultobj = 0;
45002 int arg1 ;
45003 int arg2 ;
45004 int arg3 ;
45005 int arg4 ;
45006 int arg5 ;
45007 PyObject *arg6 = (PyObject *) NULL ;
45008 wxSizerItem *result = 0 ;
45009 int val1 ;
45010 int ecode1 = 0 ;
45011 int val2 ;
45012 int ecode2 = 0 ;
45013 int val3 ;
45014 int ecode3 = 0 ;
45015 int val4 ;
45016 int ecode4 = 0 ;
45017 int val5 ;
45018 int ecode5 = 0 ;
45019 PyObject * obj0 = 0 ;
45020 PyObject * obj1 = 0 ;
45021 PyObject * obj2 = 0 ;
45022 PyObject * obj3 = 0 ;
45023 PyObject * obj4 = 0 ;
45024 PyObject * obj5 = 0 ;
45025 char * kwnames[] = {
45026 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45027 };
45028
45029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45030 ecode1 = SWIG_AsVal_int(obj0, &val1);
45031 if (!SWIG_IsOK(ecode1)) {
45032 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45033 }
45034 arg1 = static_cast< int >(val1);
45035 ecode2 = SWIG_AsVal_int(obj1, &val2);
45036 if (!SWIG_IsOK(ecode2)) {
45037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45038 }
45039 arg2 = static_cast< int >(val2);
45040 ecode3 = SWIG_AsVal_int(obj2, &val3);
45041 if (!SWIG_IsOK(ecode3)) {
45042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45043 }
45044 arg3 = static_cast< int >(val3);
45045 ecode4 = SWIG_AsVal_int(obj3, &val4);
45046 if (!SWIG_IsOK(ecode4)) {
45047 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45048 }
45049 arg4 = static_cast< int >(val4);
45050 ecode5 = SWIG_AsVal_int(obj4, &val5);
45051 if (!SWIG_IsOK(ecode5)) {
45052 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45053 }
45054 arg5 = static_cast< int >(val5);
45055 if (obj5) {
45056 arg6 = obj5;
45057 }
45058 {
45059 PyThreadState* __tstate = wxPyBeginAllowThreads();
45060 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45061 wxPyEndAllowThreads(__tstate);
45062 if (PyErr_Occurred()) SWIG_fail;
45063 }
45064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45065 return resultobj;
45066 fail:
45067 return NULL;
45068 }
45069
45070
45071 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45072 PyObject *resultobj = 0;
45073 wxSizer *arg1 = (wxSizer *) 0 ;
45074 int arg2 ;
45075 int arg3 ;
45076 int arg4 ;
45077 PyObject *arg5 = (PyObject *) NULL ;
45078 wxSizerItem *result = 0 ;
45079 int res1 = 0 ;
45080 int val2 ;
45081 int ecode2 = 0 ;
45082 int val3 ;
45083 int ecode3 = 0 ;
45084 int val4 ;
45085 int ecode4 = 0 ;
45086 PyObject * obj0 = 0 ;
45087 PyObject * obj1 = 0 ;
45088 PyObject * obj2 = 0 ;
45089 PyObject * obj3 = 0 ;
45090 PyObject * obj4 = 0 ;
45091 char * kwnames[] = {
45092 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45093 };
45094
45095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45096 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45097 if (!SWIG_IsOK(res1)) {
45098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45099 }
45100 ecode2 = SWIG_AsVal_int(obj1, &val2);
45101 if (!SWIG_IsOK(ecode2)) {
45102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45103 }
45104 arg2 = static_cast< int >(val2);
45105 ecode3 = SWIG_AsVal_int(obj2, &val3);
45106 if (!SWIG_IsOK(ecode3)) {
45107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45108 }
45109 arg3 = static_cast< int >(val3);
45110 ecode4 = SWIG_AsVal_int(obj3, &val4);
45111 if (!SWIG_IsOK(ecode4)) {
45112 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45113 }
45114 arg4 = static_cast< int >(val4);
45115 if (obj4) {
45116 arg5 = obj4;
45117 }
45118 {
45119 PyThreadState* __tstate = wxPyBeginAllowThreads();
45120 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45121 wxPyEndAllowThreads(__tstate);
45122 if (PyErr_Occurred()) SWIG_fail;
45123 }
45124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45125 return resultobj;
45126 fail:
45127 return NULL;
45128 }
45129
45130
45131 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(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_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45143 }
45144 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45145 {
45146 PyThreadState* __tstate = wxPyBeginAllowThreads();
45147 (arg1)->DeleteWindows();
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_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45159 PyObject *resultobj = 0;
45160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45161 void *argp1 = 0 ;
45162 int res1 = 0 ;
45163 PyObject *swig_obj[1] ;
45164
45165 if (!args) SWIG_fail;
45166 swig_obj[0] = args;
45167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45168 if (!SWIG_IsOK(res1)) {
45169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45170 }
45171 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45172 {
45173 PyThreadState* __tstate = wxPyBeginAllowThreads();
45174 (arg1)->DetachSizer();
45175 wxPyEndAllowThreads(__tstate);
45176 if (PyErr_Occurred()) SWIG_fail;
45177 }
45178 resultobj = SWIG_Py_Void();
45179 return resultobj;
45180 fail:
45181 return NULL;
45182 }
45183
45184
45185 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45186 PyObject *resultobj = 0;
45187 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45188 wxSize result;
45189 void *argp1 = 0 ;
45190 int res1 = 0 ;
45191 PyObject *swig_obj[1] ;
45192
45193 if (!args) SWIG_fail;
45194 swig_obj[0] = args;
45195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45196 if (!SWIG_IsOK(res1)) {
45197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45198 }
45199 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45200 {
45201 PyThreadState* __tstate = wxPyBeginAllowThreads();
45202 result = (arg1)->GetSize();
45203 wxPyEndAllowThreads(__tstate);
45204 if (PyErr_Occurred()) SWIG_fail;
45205 }
45206 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45207 return resultobj;
45208 fail:
45209 return NULL;
45210 }
45211
45212
45213 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45214 PyObject *resultobj = 0;
45215 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45216 wxSize result;
45217 void *argp1 = 0 ;
45218 int res1 = 0 ;
45219 PyObject *swig_obj[1] ;
45220
45221 if (!args) SWIG_fail;
45222 swig_obj[0] = args;
45223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45224 if (!SWIG_IsOK(res1)) {
45225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45226 }
45227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45228 {
45229 PyThreadState* __tstate = wxPyBeginAllowThreads();
45230 result = (arg1)->CalcMin();
45231 wxPyEndAllowThreads(__tstate);
45232 if (PyErr_Occurred()) SWIG_fail;
45233 }
45234 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45235 return resultobj;
45236 fail:
45237 return NULL;
45238 }
45239
45240
45241 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45242 PyObject *resultobj = 0;
45243 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45244 wxPoint *arg2 = 0 ;
45245 wxSize *arg3 = 0 ;
45246 void *argp1 = 0 ;
45247 int res1 = 0 ;
45248 wxPoint temp2 ;
45249 wxSize temp3 ;
45250 PyObject * obj0 = 0 ;
45251 PyObject * obj1 = 0 ;
45252 PyObject * obj2 = 0 ;
45253 char * kwnames[] = {
45254 (char *) "self",(char *) "pos",(char *) "size", NULL
45255 };
45256
45257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45259 if (!SWIG_IsOK(res1)) {
45260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45261 }
45262 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45263 {
45264 arg2 = &temp2;
45265 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45266 }
45267 {
45268 arg3 = &temp3;
45269 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45270 }
45271 {
45272 PyThreadState* __tstate = wxPyBeginAllowThreads();
45273 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45274 wxPyEndAllowThreads(__tstate);
45275 if (PyErr_Occurred()) SWIG_fail;
45276 }
45277 resultobj = SWIG_Py_Void();
45278 return resultobj;
45279 fail:
45280 return NULL;
45281 }
45282
45283
45284 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45285 PyObject *resultobj = 0;
45286 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45287 wxSize result;
45288 void *argp1 = 0 ;
45289 int res1 = 0 ;
45290 PyObject *swig_obj[1] ;
45291
45292 if (!args) SWIG_fail;
45293 swig_obj[0] = args;
45294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45295 if (!SWIG_IsOK(res1)) {
45296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45297 }
45298 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45299 {
45300 PyThreadState* __tstate = wxPyBeginAllowThreads();
45301 result = (arg1)->GetMinSize();
45302 wxPyEndAllowThreads(__tstate);
45303 if (PyErr_Occurred()) SWIG_fail;
45304 }
45305 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45306 return resultobj;
45307 fail:
45308 return NULL;
45309 }
45310
45311
45312 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45313 PyObject *resultobj = 0;
45314 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45315 wxSize result;
45316 void *argp1 = 0 ;
45317 int res1 = 0 ;
45318 PyObject *swig_obj[1] ;
45319
45320 if (!args) SWIG_fail;
45321 swig_obj[0] = args;
45322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45323 if (!SWIG_IsOK(res1)) {
45324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45325 }
45326 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45327 {
45328 PyThreadState* __tstate = wxPyBeginAllowThreads();
45329 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45330 wxPyEndAllowThreads(__tstate);
45331 if (PyErr_Occurred()) SWIG_fail;
45332 }
45333 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45334 return resultobj;
45335 fail:
45336 return NULL;
45337 }
45338
45339
45340 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45341 PyObject *resultobj = 0;
45342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45343 int arg2 ;
45344 int arg3 ;
45345 void *argp1 = 0 ;
45346 int res1 = 0 ;
45347 int val2 ;
45348 int ecode2 = 0 ;
45349 int val3 ;
45350 int ecode3 = 0 ;
45351 PyObject * obj0 = 0 ;
45352 PyObject * obj1 = 0 ;
45353 PyObject * obj2 = 0 ;
45354 char * kwnames[] = {
45355 (char *) "self",(char *) "x",(char *) "y", NULL
45356 };
45357
45358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45360 if (!SWIG_IsOK(res1)) {
45361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45362 }
45363 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45364 ecode2 = SWIG_AsVal_int(obj1, &val2);
45365 if (!SWIG_IsOK(ecode2)) {
45366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45367 }
45368 arg2 = static_cast< int >(val2);
45369 ecode3 = SWIG_AsVal_int(obj2, &val3);
45370 if (!SWIG_IsOK(ecode3)) {
45371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45372 }
45373 arg3 = static_cast< int >(val3);
45374 {
45375 PyThreadState* __tstate = wxPyBeginAllowThreads();
45376 (arg1)->SetInitSize(arg2,arg3);
45377 wxPyEndAllowThreads(__tstate);
45378 if (PyErr_Occurred()) SWIG_fail;
45379 }
45380 resultobj = SWIG_Py_Void();
45381 return resultobj;
45382 fail:
45383 return NULL;
45384 }
45385
45386
45387 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45388 PyObject *resultobj = 0;
45389 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45390 int arg2 ;
45391 int arg3 ;
45392 void *argp1 = 0 ;
45393 int res1 = 0 ;
45394 int val2 ;
45395 int ecode2 = 0 ;
45396 int val3 ;
45397 int ecode3 = 0 ;
45398 PyObject * obj0 = 0 ;
45399 PyObject * obj1 = 0 ;
45400 PyObject * obj2 = 0 ;
45401 char * kwnames[] = {
45402 (char *) "self",(char *) "width",(char *) "height", NULL
45403 };
45404
45405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45407 if (!SWIG_IsOK(res1)) {
45408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45409 }
45410 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45411 ecode2 = SWIG_AsVal_int(obj1, &val2);
45412 if (!SWIG_IsOK(ecode2)) {
45413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45414 }
45415 arg2 = static_cast< int >(val2);
45416 ecode3 = SWIG_AsVal_int(obj2, &val3);
45417 if (!SWIG_IsOK(ecode3)) {
45418 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45419 }
45420 arg3 = static_cast< int >(val3);
45421 {
45422 PyThreadState* __tstate = wxPyBeginAllowThreads();
45423 (arg1)->SetRatio(arg2,arg3);
45424 wxPyEndAllowThreads(__tstate);
45425 if (PyErr_Occurred()) SWIG_fail;
45426 }
45427 resultobj = SWIG_Py_Void();
45428 return resultobj;
45429 fail:
45430 return NULL;
45431 }
45432
45433
45434 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45435 PyObject *resultobj = 0;
45436 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45437 wxSize *arg2 = 0 ;
45438 void *argp1 = 0 ;
45439 int res1 = 0 ;
45440 wxSize temp2 ;
45441 PyObject * obj0 = 0 ;
45442 PyObject * obj1 = 0 ;
45443 char * kwnames[] = {
45444 (char *) "self",(char *) "size", NULL
45445 };
45446
45447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45449 if (!SWIG_IsOK(res1)) {
45450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45451 }
45452 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45453 {
45454 arg2 = &temp2;
45455 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45456 }
45457 {
45458 PyThreadState* __tstate = wxPyBeginAllowThreads();
45459 (arg1)->SetRatio((wxSize const &)*arg2);
45460 wxPyEndAllowThreads(__tstate);
45461 if (PyErr_Occurred()) SWIG_fail;
45462 }
45463 resultobj = SWIG_Py_Void();
45464 return resultobj;
45465 fail:
45466 return NULL;
45467 }
45468
45469
45470 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45471 PyObject *resultobj = 0;
45472 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45473 float arg2 ;
45474 void *argp1 = 0 ;
45475 int res1 = 0 ;
45476 float val2 ;
45477 int ecode2 = 0 ;
45478 PyObject * obj0 = 0 ;
45479 PyObject * obj1 = 0 ;
45480 char * kwnames[] = {
45481 (char *) "self",(char *) "ratio", NULL
45482 };
45483
45484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45486 if (!SWIG_IsOK(res1)) {
45487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45488 }
45489 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45490 ecode2 = SWIG_AsVal_float(obj1, &val2);
45491 if (!SWIG_IsOK(ecode2)) {
45492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45493 }
45494 arg2 = static_cast< float >(val2);
45495 {
45496 PyThreadState* __tstate = wxPyBeginAllowThreads();
45497 (arg1)->SetRatio(arg2);
45498 wxPyEndAllowThreads(__tstate);
45499 if (PyErr_Occurred()) SWIG_fail;
45500 }
45501 resultobj = SWIG_Py_Void();
45502 return resultobj;
45503 fail:
45504 return NULL;
45505 }
45506
45507
45508 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45509 PyObject *resultobj = 0;
45510 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45511 float result;
45512 void *argp1 = 0 ;
45513 int res1 = 0 ;
45514 PyObject *swig_obj[1] ;
45515
45516 if (!args) SWIG_fail;
45517 swig_obj[0] = args;
45518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45519 if (!SWIG_IsOK(res1)) {
45520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45521 }
45522 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45523 {
45524 PyThreadState* __tstate = wxPyBeginAllowThreads();
45525 result = (float)(arg1)->GetRatio();
45526 wxPyEndAllowThreads(__tstate);
45527 if (PyErr_Occurred()) SWIG_fail;
45528 }
45529 resultobj = SWIG_From_float(static_cast< float >(result));
45530 return resultobj;
45531 fail:
45532 return NULL;
45533 }
45534
45535
45536 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45537 PyObject *resultobj = 0;
45538 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45539 wxRect result;
45540 void *argp1 = 0 ;
45541 int res1 = 0 ;
45542 PyObject *swig_obj[1] ;
45543
45544 if (!args) SWIG_fail;
45545 swig_obj[0] = args;
45546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45547 if (!SWIG_IsOK(res1)) {
45548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45549 }
45550 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45551 {
45552 PyThreadState* __tstate = wxPyBeginAllowThreads();
45553 result = (arg1)->GetRect();
45554 wxPyEndAllowThreads(__tstate);
45555 if (PyErr_Occurred()) SWIG_fail;
45556 }
45557 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45558 return resultobj;
45559 fail:
45560 return NULL;
45561 }
45562
45563
45564 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45565 PyObject *resultobj = 0;
45566 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45567 bool result;
45568 void *argp1 = 0 ;
45569 int res1 = 0 ;
45570 PyObject *swig_obj[1] ;
45571
45572 if (!args) SWIG_fail;
45573 swig_obj[0] = args;
45574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45575 if (!SWIG_IsOK(res1)) {
45576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45577 }
45578 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45579 {
45580 PyThreadState* __tstate = wxPyBeginAllowThreads();
45581 result = (bool)(arg1)->IsWindow();
45582 wxPyEndAllowThreads(__tstate);
45583 if (PyErr_Occurred()) SWIG_fail;
45584 }
45585 {
45586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45587 }
45588 return resultobj;
45589 fail:
45590 return NULL;
45591 }
45592
45593
45594 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45595 PyObject *resultobj = 0;
45596 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45597 bool result;
45598 void *argp1 = 0 ;
45599 int res1 = 0 ;
45600 PyObject *swig_obj[1] ;
45601
45602 if (!args) SWIG_fail;
45603 swig_obj[0] = args;
45604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45605 if (!SWIG_IsOK(res1)) {
45606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45607 }
45608 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45609 {
45610 PyThreadState* __tstate = wxPyBeginAllowThreads();
45611 result = (bool)(arg1)->IsSizer();
45612 wxPyEndAllowThreads(__tstate);
45613 if (PyErr_Occurred()) SWIG_fail;
45614 }
45615 {
45616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45617 }
45618 return resultobj;
45619 fail:
45620 return NULL;
45621 }
45622
45623
45624 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45625 PyObject *resultobj = 0;
45626 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45627 bool result;
45628 void *argp1 = 0 ;
45629 int res1 = 0 ;
45630 PyObject *swig_obj[1] ;
45631
45632 if (!args) SWIG_fail;
45633 swig_obj[0] = args;
45634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45635 if (!SWIG_IsOK(res1)) {
45636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45637 }
45638 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45639 {
45640 PyThreadState* __tstate = wxPyBeginAllowThreads();
45641 result = (bool)(arg1)->IsSpacer();
45642 wxPyEndAllowThreads(__tstate);
45643 if (PyErr_Occurred()) SWIG_fail;
45644 }
45645 {
45646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45647 }
45648 return resultobj;
45649 fail:
45650 return NULL;
45651 }
45652
45653
45654 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45655 PyObject *resultobj = 0;
45656 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45657 int arg2 ;
45658 void *argp1 = 0 ;
45659 int res1 = 0 ;
45660 int val2 ;
45661 int ecode2 = 0 ;
45662 PyObject * obj0 = 0 ;
45663 PyObject * obj1 = 0 ;
45664 char * kwnames[] = {
45665 (char *) "self",(char *) "proportion", NULL
45666 };
45667
45668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45670 if (!SWIG_IsOK(res1)) {
45671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45672 }
45673 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45674 ecode2 = SWIG_AsVal_int(obj1, &val2);
45675 if (!SWIG_IsOK(ecode2)) {
45676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45677 }
45678 arg2 = static_cast< int >(val2);
45679 {
45680 PyThreadState* __tstate = wxPyBeginAllowThreads();
45681 (arg1)->SetProportion(arg2);
45682 wxPyEndAllowThreads(__tstate);
45683 if (PyErr_Occurred()) SWIG_fail;
45684 }
45685 resultobj = SWIG_Py_Void();
45686 return resultobj;
45687 fail:
45688 return NULL;
45689 }
45690
45691
45692 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45693 PyObject *resultobj = 0;
45694 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45695 int result;
45696 void *argp1 = 0 ;
45697 int res1 = 0 ;
45698 PyObject *swig_obj[1] ;
45699
45700 if (!args) SWIG_fail;
45701 swig_obj[0] = args;
45702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45703 if (!SWIG_IsOK(res1)) {
45704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45705 }
45706 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45707 {
45708 PyThreadState* __tstate = wxPyBeginAllowThreads();
45709 result = (int)(arg1)->GetProportion();
45710 wxPyEndAllowThreads(__tstate);
45711 if (PyErr_Occurred()) SWIG_fail;
45712 }
45713 resultobj = SWIG_From_int(static_cast< int >(result));
45714 return resultobj;
45715 fail:
45716 return NULL;
45717 }
45718
45719
45720 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45721 PyObject *resultobj = 0;
45722 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45723 int arg2 ;
45724 void *argp1 = 0 ;
45725 int res1 = 0 ;
45726 int val2 ;
45727 int ecode2 = 0 ;
45728 PyObject * obj0 = 0 ;
45729 PyObject * obj1 = 0 ;
45730 char * kwnames[] = {
45731 (char *) "self",(char *) "flag", NULL
45732 };
45733
45734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45736 if (!SWIG_IsOK(res1)) {
45737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45738 }
45739 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45740 ecode2 = SWIG_AsVal_int(obj1, &val2);
45741 if (!SWIG_IsOK(ecode2)) {
45742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45743 }
45744 arg2 = static_cast< int >(val2);
45745 {
45746 PyThreadState* __tstate = wxPyBeginAllowThreads();
45747 (arg1)->SetFlag(arg2);
45748 wxPyEndAllowThreads(__tstate);
45749 if (PyErr_Occurred()) SWIG_fail;
45750 }
45751 resultobj = SWIG_Py_Void();
45752 return resultobj;
45753 fail:
45754 return NULL;
45755 }
45756
45757
45758 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45759 PyObject *resultobj = 0;
45760 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45761 int result;
45762 void *argp1 = 0 ;
45763 int res1 = 0 ;
45764 PyObject *swig_obj[1] ;
45765
45766 if (!args) SWIG_fail;
45767 swig_obj[0] = args;
45768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45769 if (!SWIG_IsOK(res1)) {
45770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45771 }
45772 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45773 {
45774 PyThreadState* __tstate = wxPyBeginAllowThreads();
45775 result = (int)(arg1)->GetFlag();
45776 wxPyEndAllowThreads(__tstate);
45777 if (PyErr_Occurred()) SWIG_fail;
45778 }
45779 resultobj = SWIG_From_int(static_cast< int >(result));
45780 return resultobj;
45781 fail:
45782 return NULL;
45783 }
45784
45785
45786 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45787 PyObject *resultobj = 0;
45788 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45789 int arg2 ;
45790 void *argp1 = 0 ;
45791 int res1 = 0 ;
45792 int val2 ;
45793 int ecode2 = 0 ;
45794 PyObject * obj0 = 0 ;
45795 PyObject * obj1 = 0 ;
45796 char * kwnames[] = {
45797 (char *) "self",(char *) "border", NULL
45798 };
45799
45800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45802 if (!SWIG_IsOK(res1)) {
45803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45804 }
45805 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45806 ecode2 = SWIG_AsVal_int(obj1, &val2);
45807 if (!SWIG_IsOK(ecode2)) {
45808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45809 }
45810 arg2 = static_cast< int >(val2);
45811 {
45812 PyThreadState* __tstate = wxPyBeginAllowThreads();
45813 (arg1)->SetBorder(arg2);
45814 wxPyEndAllowThreads(__tstate);
45815 if (PyErr_Occurred()) SWIG_fail;
45816 }
45817 resultobj = SWIG_Py_Void();
45818 return resultobj;
45819 fail:
45820 return NULL;
45821 }
45822
45823
45824 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45825 PyObject *resultobj = 0;
45826 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45827 int result;
45828 void *argp1 = 0 ;
45829 int res1 = 0 ;
45830 PyObject *swig_obj[1] ;
45831
45832 if (!args) SWIG_fail;
45833 swig_obj[0] = args;
45834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45835 if (!SWIG_IsOK(res1)) {
45836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45837 }
45838 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45839 {
45840 PyThreadState* __tstate = wxPyBeginAllowThreads();
45841 result = (int)(arg1)->GetBorder();
45842 wxPyEndAllowThreads(__tstate);
45843 if (PyErr_Occurred()) SWIG_fail;
45844 }
45845 resultobj = SWIG_From_int(static_cast< int >(result));
45846 return resultobj;
45847 fail:
45848 return NULL;
45849 }
45850
45851
45852 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45853 PyObject *resultobj = 0;
45854 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45855 wxWindow *result = 0 ;
45856 void *argp1 = 0 ;
45857 int res1 = 0 ;
45858 PyObject *swig_obj[1] ;
45859
45860 if (!args) SWIG_fail;
45861 swig_obj[0] = args;
45862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45863 if (!SWIG_IsOK(res1)) {
45864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45865 }
45866 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45867 {
45868 PyThreadState* __tstate = wxPyBeginAllowThreads();
45869 result = (wxWindow *)(arg1)->GetWindow();
45870 wxPyEndAllowThreads(__tstate);
45871 if (PyErr_Occurred()) SWIG_fail;
45872 }
45873 {
45874 resultobj = wxPyMake_wxObject(result, 0);
45875 }
45876 return resultobj;
45877 fail:
45878 return NULL;
45879 }
45880
45881
45882 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45883 PyObject *resultobj = 0;
45884 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45885 wxWindow *arg2 = (wxWindow *) 0 ;
45886 void *argp1 = 0 ;
45887 int res1 = 0 ;
45888 void *argp2 = 0 ;
45889 int res2 = 0 ;
45890 PyObject * obj0 = 0 ;
45891 PyObject * obj1 = 0 ;
45892 char * kwnames[] = {
45893 (char *) "self",(char *) "window", NULL
45894 };
45895
45896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45898 if (!SWIG_IsOK(res1)) {
45899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45900 }
45901 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45902 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45903 if (!SWIG_IsOK(res2)) {
45904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45905 }
45906 arg2 = reinterpret_cast< wxWindow * >(argp2);
45907 {
45908 PyThreadState* __tstate = wxPyBeginAllowThreads();
45909 (arg1)->SetWindow(arg2);
45910 wxPyEndAllowThreads(__tstate);
45911 if (PyErr_Occurred()) SWIG_fail;
45912 }
45913 resultobj = SWIG_Py_Void();
45914 return resultobj;
45915 fail:
45916 return NULL;
45917 }
45918
45919
45920 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45921 PyObject *resultobj = 0;
45922 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45923 wxSizer *result = 0 ;
45924 void *argp1 = 0 ;
45925 int res1 = 0 ;
45926 PyObject *swig_obj[1] ;
45927
45928 if (!args) SWIG_fail;
45929 swig_obj[0] = args;
45930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45931 if (!SWIG_IsOK(res1)) {
45932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45933 }
45934 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45935 {
45936 PyThreadState* __tstate = wxPyBeginAllowThreads();
45937 result = (wxSizer *)(arg1)->GetSizer();
45938 wxPyEndAllowThreads(__tstate);
45939 if (PyErr_Occurred()) SWIG_fail;
45940 }
45941 {
45942 resultobj = wxPyMake_wxObject(result, (bool)0);
45943 }
45944 return resultobj;
45945 fail:
45946 return NULL;
45947 }
45948
45949
45950 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45951 PyObject *resultobj = 0;
45952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45953 wxSizer *arg2 = (wxSizer *) 0 ;
45954 void *argp1 = 0 ;
45955 int res1 = 0 ;
45956 int res2 = 0 ;
45957 PyObject * obj0 = 0 ;
45958 PyObject * obj1 = 0 ;
45959 char * kwnames[] = {
45960 (char *) "self",(char *) "sizer", NULL
45961 };
45962
45963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45965 if (!SWIG_IsOK(res1)) {
45966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45967 }
45968 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45969 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45970 if (!SWIG_IsOK(res2)) {
45971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45972 }
45973 {
45974 PyThreadState* __tstate = wxPyBeginAllowThreads();
45975 (arg1)->SetSizer(arg2);
45976 wxPyEndAllowThreads(__tstate);
45977 if (PyErr_Occurred()) SWIG_fail;
45978 }
45979 resultobj = SWIG_Py_Void();
45980 return resultobj;
45981 fail:
45982 return NULL;
45983 }
45984
45985
45986 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45987 PyObject *resultobj = 0;
45988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45989 wxSize *result = 0 ;
45990 void *argp1 = 0 ;
45991 int res1 = 0 ;
45992 PyObject *swig_obj[1] ;
45993
45994 if (!args) SWIG_fail;
45995 swig_obj[0] = args;
45996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45997 if (!SWIG_IsOK(res1)) {
45998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45999 }
46000 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46001 {
46002 PyThreadState* __tstate = wxPyBeginAllowThreads();
46003 {
46004 wxSize const &_result_ref = (arg1)->GetSpacer();
46005 result = (wxSize *) &_result_ref;
46006 }
46007 wxPyEndAllowThreads(__tstate);
46008 if (PyErr_Occurred()) SWIG_fail;
46009 }
46010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46011 return resultobj;
46012 fail:
46013 return NULL;
46014 }
46015
46016
46017 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46018 PyObject *resultobj = 0;
46019 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46020 wxSize *arg2 = 0 ;
46021 void *argp1 = 0 ;
46022 int res1 = 0 ;
46023 wxSize temp2 ;
46024 PyObject * obj0 = 0 ;
46025 PyObject * obj1 = 0 ;
46026 char * kwnames[] = {
46027 (char *) "self",(char *) "size", NULL
46028 };
46029
46030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46032 if (!SWIG_IsOK(res1)) {
46033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46034 }
46035 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46036 {
46037 arg2 = &temp2;
46038 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46039 }
46040 {
46041 PyThreadState* __tstate = wxPyBeginAllowThreads();
46042 (arg1)->SetSpacer((wxSize const &)*arg2);
46043 wxPyEndAllowThreads(__tstate);
46044 if (PyErr_Occurred()) SWIG_fail;
46045 }
46046 resultobj = SWIG_Py_Void();
46047 return resultobj;
46048 fail:
46049 return NULL;
46050 }
46051
46052
46053 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46054 PyObject *resultobj = 0;
46055 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46056 bool arg2 ;
46057 void *argp1 = 0 ;
46058 int res1 = 0 ;
46059 bool val2 ;
46060 int ecode2 = 0 ;
46061 PyObject * obj0 = 0 ;
46062 PyObject * obj1 = 0 ;
46063 char * kwnames[] = {
46064 (char *) "self",(char *) "show", NULL
46065 };
46066
46067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46069 if (!SWIG_IsOK(res1)) {
46070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46071 }
46072 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46073 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46074 if (!SWIG_IsOK(ecode2)) {
46075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46076 }
46077 arg2 = static_cast< bool >(val2);
46078 {
46079 PyThreadState* __tstate = wxPyBeginAllowThreads();
46080 (arg1)->Show(arg2);
46081 wxPyEndAllowThreads(__tstate);
46082 if (PyErr_Occurred()) SWIG_fail;
46083 }
46084 resultobj = SWIG_Py_Void();
46085 return resultobj;
46086 fail:
46087 return NULL;
46088 }
46089
46090
46091 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46092 PyObject *resultobj = 0;
46093 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46094 bool result;
46095 void *argp1 = 0 ;
46096 int res1 = 0 ;
46097 PyObject *swig_obj[1] ;
46098
46099 if (!args) SWIG_fail;
46100 swig_obj[0] = args;
46101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46102 if (!SWIG_IsOK(res1)) {
46103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46104 }
46105 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46106 {
46107 PyThreadState* __tstate = wxPyBeginAllowThreads();
46108 result = (bool)(arg1)->IsShown();
46109 wxPyEndAllowThreads(__tstate);
46110 if (PyErr_Occurred()) SWIG_fail;
46111 }
46112 {
46113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46114 }
46115 return resultobj;
46116 fail:
46117 return NULL;
46118 }
46119
46120
46121 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46122 PyObject *resultobj = 0;
46123 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46124 wxPoint result;
46125 void *argp1 = 0 ;
46126 int res1 = 0 ;
46127 PyObject *swig_obj[1] ;
46128
46129 if (!args) SWIG_fail;
46130 swig_obj[0] = args;
46131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46132 if (!SWIG_IsOK(res1)) {
46133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46134 }
46135 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46136 {
46137 PyThreadState* __tstate = wxPyBeginAllowThreads();
46138 result = (arg1)->GetPosition();
46139 wxPyEndAllowThreads(__tstate);
46140 if (PyErr_Occurred()) SWIG_fail;
46141 }
46142 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46143 return resultobj;
46144 fail:
46145 return NULL;
46146 }
46147
46148
46149 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46150 PyObject *resultobj = 0;
46151 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46152 PyObject *result = 0 ;
46153 void *argp1 = 0 ;
46154 int res1 = 0 ;
46155 PyObject *swig_obj[1] ;
46156
46157 if (!args) SWIG_fail;
46158 swig_obj[0] = args;
46159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46160 if (!SWIG_IsOK(res1)) {
46161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46162 }
46163 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46164 {
46165 PyThreadState* __tstate = wxPyBeginAllowThreads();
46166 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46167 wxPyEndAllowThreads(__tstate);
46168 if (PyErr_Occurred()) SWIG_fail;
46169 }
46170 resultobj = result;
46171 return resultobj;
46172 fail:
46173 return NULL;
46174 }
46175
46176
46177 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46178 PyObject *resultobj = 0;
46179 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46180 PyObject *arg2 = (PyObject *) 0 ;
46181 void *argp1 = 0 ;
46182 int res1 = 0 ;
46183 PyObject * obj0 = 0 ;
46184 PyObject * obj1 = 0 ;
46185 char * kwnames[] = {
46186 (char *) "self",(char *) "userData", NULL
46187 };
46188
46189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46191 if (!SWIG_IsOK(res1)) {
46192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46193 }
46194 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46195 arg2 = obj1;
46196 {
46197 PyThreadState* __tstate = wxPyBeginAllowThreads();
46198 wxSizerItem_SetUserData(arg1,arg2);
46199 wxPyEndAllowThreads(__tstate);
46200 if (PyErr_Occurred()) SWIG_fail;
46201 }
46202 resultobj = SWIG_Py_Void();
46203 return resultobj;
46204 fail:
46205 return NULL;
46206 }
46207
46208
46209 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46210 PyObject *obj;
46211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46212 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46213 return SWIG_Py_Void();
46214 }
46215
46216 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46217 return SWIG_Python_InitShadowInstance(args);
46218 }
46219
46220 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46221 PyObject *resultobj = 0;
46222 wxSizer *arg1 = (wxSizer *) 0 ;
46223 void *argp1 = 0 ;
46224 int res1 = 0 ;
46225 PyObject *swig_obj[1] ;
46226
46227 if (!args) SWIG_fail;
46228 swig_obj[0] = args;
46229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46230 if (!SWIG_IsOK(res1)) {
46231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46232 }
46233 arg1 = reinterpret_cast< wxSizer * >(argp1);
46234 {
46235 PyThreadState* __tstate = wxPyBeginAllowThreads();
46236 delete arg1;
46237
46238 wxPyEndAllowThreads(__tstate);
46239 if (PyErr_Occurred()) SWIG_fail;
46240 }
46241 resultobj = SWIG_Py_Void();
46242 return resultobj;
46243 fail:
46244 return NULL;
46245 }
46246
46247
46248 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46249 PyObject *resultobj = 0;
46250 wxSizer *arg1 = (wxSizer *) 0 ;
46251 PyObject *arg2 = (PyObject *) 0 ;
46252 void *argp1 = 0 ;
46253 int res1 = 0 ;
46254 PyObject * obj0 = 0 ;
46255 PyObject * obj1 = 0 ;
46256 char * kwnames[] = {
46257 (char *) "self",(char *) "_self", NULL
46258 };
46259
46260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46262 if (!SWIG_IsOK(res1)) {
46263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46264 }
46265 arg1 = reinterpret_cast< wxSizer * >(argp1);
46266 arg2 = obj1;
46267 {
46268 PyThreadState* __tstate = wxPyBeginAllowThreads();
46269 wxSizer__setOORInfo(arg1,arg2);
46270 wxPyEndAllowThreads(__tstate);
46271 if (PyErr_Occurred()) SWIG_fail;
46272 }
46273 resultobj = SWIG_Py_Void();
46274 return resultobj;
46275 fail:
46276 return NULL;
46277 }
46278
46279
46280 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46281 PyObject *resultobj = 0;
46282 wxSizer *arg1 = (wxSizer *) 0 ;
46283 PyObject *arg2 = (PyObject *) 0 ;
46284 int arg3 = (int) 0 ;
46285 int arg4 = (int) 0 ;
46286 int arg5 = (int) 0 ;
46287 PyObject *arg6 = (PyObject *) NULL ;
46288 wxSizerItem *result = 0 ;
46289 void *argp1 = 0 ;
46290 int res1 = 0 ;
46291 int val3 ;
46292 int ecode3 = 0 ;
46293 int val4 ;
46294 int ecode4 = 0 ;
46295 int val5 ;
46296 int ecode5 = 0 ;
46297 PyObject * obj0 = 0 ;
46298 PyObject * obj1 = 0 ;
46299 PyObject * obj2 = 0 ;
46300 PyObject * obj3 = 0 ;
46301 PyObject * obj4 = 0 ;
46302 PyObject * obj5 = 0 ;
46303 char * kwnames[] = {
46304 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46305 };
46306
46307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46309 if (!SWIG_IsOK(res1)) {
46310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46311 }
46312 arg1 = reinterpret_cast< wxSizer * >(argp1);
46313 arg2 = obj1;
46314 if (obj2) {
46315 ecode3 = SWIG_AsVal_int(obj2, &val3);
46316 if (!SWIG_IsOK(ecode3)) {
46317 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46318 }
46319 arg3 = static_cast< int >(val3);
46320 }
46321 if (obj3) {
46322 ecode4 = SWIG_AsVal_int(obj3, &val4);
46323 if (!SWIG_IsOK(ecode4)) {
46324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46325 }
46326 arg4 = static_cast< int >(val4);
46327 }
46328 if (obj4) {
46329 ecode5 = SWIG_AsVal_int(obj4, &val5);
46330 if (!SWIG_IsOK(ecode5)) {
46331 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46332 }
46333 arg5 = static_cast< int >(val5);
46334 }
46335 if (obj5) {
46336 arg6 = obj5;
46337 }
46338 {
46339 PyThreadState* __tstate = wxPyBeginAllowThreads();
46340 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46341 wxPyEndAllowThreads(__tstate);
46342 if (PyErr_Occurred()) SWIG_fail;
46343 }
46344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46345 return resultobj;
46346 fail:
46347 return NULL;
46348 }
46349
46350
46351 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46352 PyObject *resultobj = 0;
46353 wxSizer *arg1 = (wxSizer *) 0 ;
46354 int arg2 ;
46355 PyObject *arg3 = (PyObject *) 0 ;
46356 int arg4 = (int) 0 ;
46357 int arg5 = (int) 0 ;
46358 int arg6 = (int) 0 ;
46359 PyObject *arg7 = (PyObject *) NULL ;
46360 wxSizerItem *result = 0 ;
46361 void *argp1 = 0 ;
46362 int res1 = 0 ;
46363 int val2 ;
46364 int ecode2 = 0 ;
46365 int val4 ;
46366 int ecode4 = 0 ;
46367 int val5 ;
46368 int ecode5 = 0 ;
46369 int val6 ;
46370 int ecode6 = 0 ;
46371 PyObject * obj0 = 0 ;
46372 PyObject * obj1 = 0 ;
46373 PyObject * obj2 = 0 ;
46374 PyObject * obj3 = 0 ;
46375 PyObject * obj4 = 0 ;
46376 PyObject * obj5 = 0 ;
46377 PyObject * obj6 = 0 ;
46378 char * kwnames[] = {
46379 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46380 };
46381
46382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46384 if (!SWIG_IsOK(res1)) {
46385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46386 }
46387 arg1 = reinterpret_cast< wxSizer * >(argp1);
46388 ecode2 = SWIG_AsVal_int(obj1, &val2);
46389 if (!SWIG_IsOK(ecode2)) {
46390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46391 }
46392 arg2 = static_cast< int >(val2);
46393 arg3 = obj2;
46394 if (obj3) {
46395 ecode4 = SWIG_AsVal_int(obj3, &val4);
46396 if (!SWIG_IsOK(ecode4)) {
46397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46398 }
46399 arg4 = static_cast< int >(val4);
46400 }
46401 if (obj4) {
46402 ecode5 = SWIG_AsVal_int(obj4, &val5);
46403 if (!SWIG_IsOK(ecode5)) {
46404 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46405 }
46406 arg5 = static_cast< int >(val5);
46407 }
46408 if (obj5) {
46409 ecode6 = SWIG_AsVal_int(obj5, &val6);
46410 if (!SWIG_IsOK(ecode6)) {
46411 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46412 }
46413 arg6 = static_cast< int >(val6);
46414 }
46415 if (obj6) {
46416 arg7 = obj6;
46417 }
46418 {
46419 PyThreadState* __tstate = wxPyBeginAllowThreads();
46420 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46421 wxPyEndAllowThreads(__tstate);
46422 if (PyErr_Occurred()) SWIG_fail;
46423 }
46424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46425 return resultobj;
46426 fail:
46427 return NULL;
46428 }
46429
46430
46431 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46432 PyObject *resultobj = 0;
46433 wxSizer *arg1 = (wxSizer *) 0 ;
46434 PyObject *arg2 = (PyObject *) 0 ;
46435 int arg3 = (int) 0 ;
46436 int arg4 = (int) 0 ;
46437 int arg5 = (int) 0 ;
46438 PyObject *arg6 = (PyObject *) NULL ;
46439 wxSizerItem *result = 0 ;
46440 void *argp1 = 0 ;
46441 int res1 = 0 ;
46442 int val3 ;
46443 int ecode3 = 0 ;
46444 int val4 ;
46445 int ecode4 = 0 ;
46446 int val5 ;
46447 int ecode5 = 0 ;
46448 PyObject * obj0 = 0 ;
46449 PyObject * obj1 = 0 ;
46450 PyObject * obj2 = 0 ;
46451 PyObject * obj3 = 0 ;
46452 PyObject * obj4 = 0 ;
46453 PyObject * obj5 = 0 ;
46454 char * kwnames[] = {
46455 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46456 };
46457
46458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46460 if (!SWIG_IsOK(res1)) {
46461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46462 }
46463 arg1 = reinterpret_cast< wxSizer * >(argp1);
46464 arg2 = obj1;
46465 if (obj2) {
46466 ecode3 = SWIG_AsVal_int(obj2, &val3);
46467 if (!SWIG_IsOK(ecode3)) {
46468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46469 }
46470 arg3 = static_cast< int >(val3);
46471 }
46472 if (obj3) {
46473 ecode4 = SWIG_AsVal_int(obj3, &val4);
46474 if (!SWIG_IsOK(ecode4)) {
46475 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46476 }
46477 arg4 = static_cast< int >(val4);
46478 }
46479 if (obj4) {
46480 ecode5 = SWIG_AsVal_int(obj4, &val5);
46481 if (!SWIG_IsOK(ecode5)) {
46482 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46483 }
46484 arg5 = static_cast< int >(val5);
46485 }
46486 if (obj5) {
46487 arg6 = obj5;
46488 }
46489 {
46490 PyThreadState* __tstate = wxPyBeginAllowThreads();
46491 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46492 wxPyEndAllowThreads(__tstate);
46493 if (PyErr_Occurred()) SWIG_fail;
46494 }
46495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46496 return resultobj;
46497 fail:
46498 return NULL;
46499 }
46500
46501
46502 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46503 PyObject *resultobj = 0;
46504 wxSizer *arg1 = (wxSizer *) 0 ;
46505 PyObject *arg2 = (PyObject *) 0 ;
46506 bool result;
46507 void *argp1 = 0 ;
46508 int res1 = 0 ;
46509 PyObject * obj0 = 0 ;
46510 PyObject * obj1 = 0 ;
46511 char * kwnames[] = {
46512 (char *) "self",(char *) "item", NULL
46513 };
46514
46515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46517 if (!SWIG_IsOK(res1)) {
46518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46519 }
46520 arg1 = reinterpret_cast< wxSizer * >(argp1);
46521 arg2 = obj1;
46522 {
46523 PyThreadState* __tstate = wxPyBeginAllowThreads();
46524 result = (bool)wxSizer_Remove(arg1,arg2);
46525 wxPyEndAllowThreads(__tstate);
46526 if (PyErr_Occurred()) SWIG_fail;
46527 }
46528 {
46529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46530 }
46531 return resultobj;
46532 fail:
46533 return NULL;
46534 }
46535
46536
46537 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46538 PyObject *resultobj = 0;
46539 wxSizer *arg1 = (wxSizer *) 0 ;
46540 PyObject *arg2 = (PyObject *) 0 ;
46541 bool result;
46542 void *argp1 = 0 ;
46543 int res1 = 0 ;
46544 PyObject * obj0 = 0 ;
46545 PyObject * obj1 = 0 ;
46546 char * kwnames[] = {
46547 (char *) "self",(char *) "item", NULL
46548 };
46549
46550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46552 if (!SWIG_IsOK(res1)) {
46553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46554 }
46555 arg1 = reinterpret_cast< wxSizer * >(argp1);
46556 arg2 = obj1;
46557 {
46558 PyThreadState* __tstate = wxPyBeginAllowThreads();
46559 result = (bool)wxSizer_Detach(arg1,arg2);
46560 wxPyEndAllowThreads(__tstate);
46561 if (PyErr_Occurred()) SWIG_fail;
46562 }
46563 {
46564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46565 }
46566 return resultobj;
46567 fail:
46568 return NULL;
46569 }
46570
46571
46572 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46573 PyObject *resultobj = 0;
46574 wxSizer *arg1 = (wxSizer *) 0 ;
46575 PyObject *arg2 = (PyObject *) 0 ;
46576 wxSizerItem *result = 0 ;
46577 void *argp1 = 0 ;
46578 int res1 = 0 ;
46579 PyObject * obj0 = 0 ;
46580 PyObject * obj1 = 0 ;
46581 char * kwnames[] = {
46582 (char *) "self",(char *) "item", NULL
46583 };
46584
46585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46587 if (!SWIG_IsOK(res1)) {
46588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46589 }
46590 arg1 = reinterpret_cast< wxSizer * >(argp1);
46591 arg2 = obj1;
46592 {
46593 PyThreadState* __tstate = wxPyBeginAllowThreads();
46594 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46595 wxPyEndAllowThreads(__tstate);
46596 if (PyErr_Occurred()) SWIG_fail;
46597 }
46598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46599 return resultobj;
46600 fail:
46601 return NULL;
46602 }
46603
46604
46605 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46606 PyObject *resultobj = 0;
46607 wxSizer *arg1 = (wxSizer *) 0 ;
46608 PyObject *arg2 = (PyObject *) 0 ;
46609 wxSize *arg3 = 0 ;
46610 void *argp1 = 0 ;
46611 int res1 = 0 ;
46612 wxSize temp3 ;
46613 PyObject * obj0 = 0 ;
46614 PyObject * obj1 = 0 ;
46615 PyObject * obj2 = 0 ;
46616 char * kwnames[] = {
46617 (char *) "self",(char *) "item",(char *) "size", NULL
46618 };
46619
46620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46622 if (!SWIG_IsOK(res1)) {
46623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46624 }
46625 arg1 = reinterpret_cast< wxSizer * >(argp1);
46626 arg2 = obj1;
46627 {
46628 arg3 = &temp3;
46629 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46630 }
46631 {
46632 PyThreadState* __tstate = wxPyBeginAllowThreads();
46633 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46634 wxPyEndAllowThreads(__tstate);
46635 if (PyErr_Occurred()) SWIG_fail;
46636 }
46637 resultobj = SWIG_Py_Void();
46638 return resultobj;
46639 fail:
46640 return NULL;
46641 }
46642
46643
46644 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46645 PyObject *resultobj = 0;
46646 wxSizer *arg1 = (wxSizer *) 0 ;
46647 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46648 wxSizerItem *result = 0 ;
46649 void *argp1 = 0 ;
46650 int res1 = 0 ;
46651 int res2 = 0 ;
46652 PyObject * obj0 = 0 ;
46653 PyObject * obj1 = 0 ;
46654 char * kwnames[] = {
46655 (char *) "self",(char *) "item", NULL
46656 };
46657
46658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46660 if (!SWIG_IsOK(res1)) {
46661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46662 }
46663 arg1 = reinterpret_cast< wxSizer * >(argp1);
46664 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46665 if (!SWIG_IsOK(res2)) {
46666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46667 }
46668 {
46669 PyThreadState* __tstate = wxPyBeginAllowThreads();
46670 result = (wxSizerItem *)(arg1)->Add(arg2);
46671 wxPyEndAllowThreads(__tstate);
46672 if (PyErr_Occurred()) SWIG_fail;
46673 }
46674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46675 return resultobj;
46676 fail:
46677 return NULL;
46678 }
46679
46680
46681 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46682 PyObject *resultobj = 0;
46683 wxSizer *arg1 = (wxSizer *) 0 ;
46684 size_t arg2 ;
46685 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46686 wxSizerItem *result = 0 ;
46687 void *argp1 = 0 ;
46688 int res1 = 0 ;
46689 size_t val2 ;
46690 int ecode2 = 0 ;
46691 int res3 = 0 ;
46692 PyObject * obj0 = 0 ;
46693 PyObject * obj1 = 0 ;
46694 PyObject * obj2 = 0 ;
46695 char * kwnames[] = {
46696 (char *) "self",(char *) "index",(char *) "item", NULL
46697 };
46698
46699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46701 if (!SWIG_IsOK(res1)) {
46702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46703 }
46704 arg1 = reinterpret_cast< wxSizer * >(argp1);
46705 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46706 if (!SWIG_IsOK(ecode2)) {
46707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46708 }
46709 arg2 = static_cast< size_t >(val2);
46710 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46711 if (!SWIG_IsOK(res3)) {
46712 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46713 }
46714 {
46715 PyThreadState* __tstate = wxPyBeginAllowThreads();
46716 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46717 wxPyEndAllowThreads(__tstate);
46718 if (PyErr_Occurred()) SWIG_fail;
46719 }
46720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46721 return resultobj;
46722 fail:
46723 return NULL;
46724 }
46725
46726
46727 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46728 PyObject *resultobj = 0;
46729 wxSizer *arg1 = (wxSizer *) 0 ;
46730 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46731 wxSizerItem *result = 0 ;
46732 void *argp1 = 0 ;
46733 int res1 = 0 ;
46734 int res2 = 0 ;
46735 PyObject * obj0 = 0 ;
46736 PyObject * obj1 = 0 ;
46737 char * kwnames[] = {
46738 (char *) "self",(char *) "item", NULL
46739 };
46740
46741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46743 if (!SWIG_IsOK(res1)) {
46744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46745 }
46746 arg1 = reinterpret_cast< wxSizer * >(argp1);
46747 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46748 if (!SWIG_IsOK(res2)) {
46749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46750 }
46751 {
46752 PyThreadState* __tstate = wxPyBeginAllowThreads();
46753 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46754 wxPyEndAllowThreads(__tstate);
46755 if (PyErr_Occurred()) SWIG_fail;
46756 }
46757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46758 return resultobj;
46759 fail:
46760 return NULL;
46761 }
46762
46763
46764 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46765 PyObject *resultobj = 0;
46766 wxSizer *arg1 = (wxSizer *) 0 ;
46767 int arg2 ;
46768 int arg3 ;
46769 int arg4 ;
46770 int arg5 ;
46771 void *argp1 = 0 ;
46772 int res1 = 0 ;
46773 int val2 ;
46774 int ecode2 = 0 ;
46775 int val3 ;
46776 int ecode3 = 0 ;
46777 int val4 ;
46778 int ecode4 = 0 ;
46779 int val5 ;
46780 int ecode5 = 0 ;
46781 PyObject * obj0 = 0 ;
46782 PyObject * obj1 = 0 ;
46783 PyObject * obj2 = 0 ;
46784 PyObject * obj3 = 0 ;
46785 PyObject * obj4 = 0 ;
46786 char * kwnames[] = {
46787 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46788 };
46789
46790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46792 if (!SWIG_IsOK(res1)) {
46793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46794 }
46795 arg1 = reinterpret_cast< wxSizer * >(argp1);
46796 ecode2 = SWIG_AsVal_int(obj1, &val2);
46797 if (!SWIG_IsOK(ecode2)) {
46798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46799 }
46800 arg2 = static_cast< int >(val2);
46801 ecode3 = SWIG_AsVal_int(obj2, &val3);
46802 if (!SWIG_IsOK(ecode3)) {
46803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46804 }
46805 arg3 = static_cast< int >(val3);
46806 ecode4 = SWIG_AsVal_int(obj3, &val4);
46807 if (!SWIG_IsOK(ecode4)) {
46808 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46809 }
46810 arg4 = static_cast< int >(val4);
46811 ecode5 = SWIG_AsVal_int(obj4, &val5);
46812 if (!SWIG_IsOK(ecode5)) {
46813 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46814 }
46815 arg5 = static_cast< int >(val5);
46816 {
46817 PyThreadState* __tstate = wxPyBeginAllowThreads();
46818 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46819 wxPyEndAllowThreads(__tstate);
46820 if (PyErr_Occurred()) SWIG_fail;
46821 }
46822 resultobj = SWIG_Py_Void();
46823 return resultobj;
46824 fail:
46825 return NULL;
46826 }
46827
46828
46829 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46830 PyObject *resultobj = 0;
46831 wxSizer *arg1 = (wxSizer *) 0 ;
46832 wxSize *arg2 = 0 ;
46833 void *argp1 = 0 ;
46834 int res1 = 0 ;
46835 wxSize temp2 ;
46836 PyObject * obj0 = 0 ;
46837 PyObject * obj1 = 0 ;
46838 char * kwnames[] = {
46839 (char *) "self",(char *) "size", NULL
46840 };
46841
46842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46844 if (!SWIG_IsOK(res1)) {
46845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46846 }
46847 arg1 = reinterpret_cast< wxSizer * >(argp1);
46848 {
46849 arg2 = &temp2;
46850 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46851 }
46852 {
46853 PyThreadState* __tstate = wxPyBeginAllowThreads();
46854 (arg1)->SetMinSize((wxSize const &)*arg2);
46855 wxPyEndAllowThreads(__tstate);
46856 if (PyErr_Occurred()) SWIG_fail;
46857 }
46858 resultobj = SWIG_Py_Void();
46859 return resultobj;
46860 fail:
46861 return NULL;
46862 }
46863
46864
46865 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46866 PyObject *resultobj = 0;
46867 wxSizer *arg1 = (wxSizer *) 0 ;
46868 wxSize result;
46869 void *argp1 = 0 ;
46870 int res1 = 0 ;
46871 PyObject *swig_obj[1] ;
46872
46873 if (!args) SWIG_fail;
46874 swig_obj[0] = args;
46875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46876 if (!SWIG_IsOK(res1)) {
46877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46878 }
46879 arg1 = reinterpret_cast< wxSizer * >(argp1);
46880 {
46881 PyThreadState* __tstate = wxPyBeginAllowThreads();
46882 result = (arg1)->GetSize();
46883 wxPyEndAllowThreads(__tstate);
46884 if (PyErr_Occurred()) SWIG_fail;
46885 }
46886 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46887 return resultobj;
46888 fail:
46889 return NULL;
46890 }
46891
46892
46893 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46894 PyObject *resultobj = 0;
46895 wxSizer *arg1 = (wxSizer *) 0 ;
46896 wxPoint result;
46897 void *argp1 = 0 ;
46898 int res1 = 0 ;
46899 PyObject *swig_obj[1] ;
46900
46901 if (!args) SWIG_fail;
46902 swig_obj[0] = args;
46903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46904 if (!SWIG_IsOK(res1)) {
46905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46906 }
46907 arg1 = reinterpret_cast< wxSizer * >(argp1);
46908 {
46909 PyThreadState* __tstate = wxPyBeginAllowThreads();
46910 result = (arg1)->GetPosition();
46911 wxPyEndAllowThreads(__tstate);
46912 if (PyErr_Occurred()) SWIG_fail;
46913 }
46914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46915 return resultobj;
46916 fail:
46917 return NULL;
46918 }
46919
46920
46921 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46922 PyObject *resultobj = 0;
46923 wxSizer *arg1 = (wxSizer *) 0 ;
46924 wxSize result;
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_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46934 }
46935 arg1 = reinterpret_cast< wxSizer * >(argp1);
46936 {
46937 PyThreadState* __tstate = wxPyBeginAllowThreads();
46938 result = (arg1)->GetMinSize();
46939 wxPyEndAllowThreads(__tstate);
46940 if (PyErr_Occurred()) SWIG_fail;
46941 }
46942 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46943 return resultobj;
46944 fail:
46945 return NULL;
46946 }
46947
46948
46949 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46950 PyObject *resultobj = 0;
46951 wxSizer *arg1 = (wxSizer *) 0 ;
46952 void *argp1 = 0 ;
46953 int res1 = 0 ;
46954 PyObject *swig_obj[1] ;
46955
46956 if (!args) SWIG_fail;
46957 swig_obj[0] = args;
46958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46959 if (!SWIG_IsOK(res1)) {
46960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46961 }
46962 arg1 = reinterpret_cast< wxSizer * >(argp1);
46963 {
46964 PyThreadState* __tstate = wxPyBeginAllowThreads();
46965 (arg1)->RecalcSizes();
46966 wxPyEndAllowThreads(__tstate);
46967 if (PyErr_Occurred()) SWIG_fail;
46968 }
46969 resultobj = SWIG_Py_Void();
46970 return resultobj;
46971 fail:
46972 return NULL;
46973 }
46974
46975
46976 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46977 PyObject *resultobj = 0;
46978 wxSizer *arg1 = (wxSizer *) 0 ;
46979 wxSize result;
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_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46989 }
46990 arg1 = reinterpret_cast< wxSizer * >(argp1);
46991 {
46992 PyThreadState* __tstate = wxPyBeginAllowThreads();
46993 result = (arg1)->CalcMin();
46994 wxPyEndAllowThreads(__tstate);
46995 if (PyErr_Occurred()) SWIG_fail;
46996 }
46997 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46998 return resultobj;
46999 fail:
47000 return NULL;
47001 }
47002
47003
47004 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47005 PyObject *resultobj = 0;
47006 wxSizer *arg1 = (wxSizer *) 0 ;
47007 void *argp1 = 0 ;
47008 int res1 = 0 ;
47009 PyObject *swig_obj[1] ;
47010
47011 if (!args) SWIG_fail;
47012 swig_obj[0] = args;
47013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47014 if (!SWIG_IsOK(res1)) {
47015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47016 }
47017 arg1 = reinterpret_cast< wxSizer * >(argp1);
47018 {
47019 PyThreadState* __tstate = wxPyBeginAllowThreads();
47020 (arg1)->Layout();
47021 wxPyEndAllowThreads(__tstate);
47022 if (PyErr_Occurred()) SWIG_fail;
47023 }
47024 resultobj = SWIG_Py_Void();
47025 return resultobj;
47026 fail:
47027 return NULL;
47028 }
47029
47030
47031 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47032 PyObject *resultobj = 0;
47033 wxSizer *arg1 = (wxSizer *) 0 ;
47034 wxWindow *arg2 = (wxWindow *) 0 ;
47035 wxSize result;
47036 void *argp1 = 0 ;
47037 int res1 = 0 ;
47038 void *argp2 = 0 ;
47039 int res2 = 0 ;
47040 PyObject * obj0 = 0 ;
47041 PyObject * obj1 = 0 ;
47042 char * kwnames[] = {
47043 (char *) "self",(char *) "window", NULL
47044 };
47045
47046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47048 if (!SWIG_IsOK(res1)) {
47049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47050 }
47051 arg1 = reinterpret_cast< wxSizer * >(argp1);
47052 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47053 if (!SWIG_IsOK(res2)) {
47054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47055 }
47056 arg2 = reinterpret_cast< wxWindow * >(argp2);
47057 {
47058 PyThreadState* __tstate = wxPyBeginAllowThreads();
47059 result = (arg1)->Fit(arg2);
47060 wxPyEndAllowThreads(__tstate);
47061 if (PyErr_Occurred()) SWIG_fail;
47062 }
47063 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47064 return resultobj;
47065 fail:
47066 return NULL;
47067 }
47068
47069
47070 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47071 PyObject *resultobj = 0;
47072 wxSizer *arg1 = (wxSizer *) 0 ;
47073 wxWindow *arg2 = (wxWindow *) 0 ;
47074 void *argp1 = 0 ;
47075 int res1 = 0 ;
47076 void *argp2 = 0 ;
47077 int res2 = 0 ;
47078 PyObject * obj0 = 0 ;
47079 PyObject * obj1 = 0 ;
47080 char * kwnames[] = {
47081 (char *) "self",(char *) "window", NULL
47082 };
47083
47084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47086 if (!SWIG_IsOK(res1)) {
47087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47088 }
47089 arg1 = reinterpret_cast< wxSizer * >(argp1);
47090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47091 if (!SWIG_IsOK(res2)) {
47092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47093 }
47094 arg2 = reinterpret_cast< wxWindow * >(argp2);
47095 {
47096 PyThreadState* __tstate = wxPyBeginAllowThreads();
47097 (arg1)->FitInside(arg2);
47098 wxPyEndAllowThreads(__tstate);
47099 if (PyErr_Occurred()) SWIG_fail;
47100 }
47101 resultobj = SWIG_Py_Void();
47102 return resultobj;
47103 fail:
47104 return NULL;
47105 }
47106
47107
47108 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47109 PyObject *resultobj = 0;
47110 wxSizer *arg1 = (wxSizer *) 0 ;
47111 wxWindow *arg2 = (wxWindow *) 0 ;
47112 void *argp1 = 0 ;
47113 int res1 = 0 ;
47114 void *argp2 = 0 ;
47115 int res2 = 0 ;
47116 PyObject * obj0 = 0 ;
47117 PyObject * obj1 = 0 ;
47118 char * kwnames[] = {
47119 (char *) "self",(char *) "window", NULL
47120 };
47121
47122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47124 if (!SWIG_IsOK(res1)) {
47125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47126 }
47127 arg1 = reinterpret_cast< wxSizer * >(argp1);
47128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47129 if (!SWIG_IsOK(res2)) {
47130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47131 }
47132 arg2 = reinterpret_cast< wxWindow * >(argp2);
47133 {
47134 PyThreadState* __tstate = wxPyBeginAllowThreads();
47135 (arg1)->SetSizeHints(arg2);
47136 wxPyEndAllowThreads(__tstate);
47137 if (PyErr_Occurred()) SWIG_fail;
47138 }
47139 resultobj = SWIG_Py_Void();
47140 return resultobj;
47141 fail:
47142 return NULL;
47143 }
47144
47145
47146 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47147 PyObject *resultobj = 0;
47148 wxSizer *arg1 = (wxSizer *) 0 ;
47149 wxWindow *arg2 = (wxWindow *) 0 ;
47150 void *argp1 = 0 ;
47151 int res1 = 0 ;
47152 void *argp2 = 0 ;
47153 int res2 = 0 ;
47154 PyObject * obj0 = 0 ;
47155 PyObject * obj1 = 0 ;
47156 char * kwnames[] = {
47157 (char *) "self",(char *) "window", NULL
47158 };
47159
47160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47162 if (!SWIG_IsOK(res1)) {
47163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47164 }
47165 arg1 = reinterpret_cast< wxSizer * >(argp1);
47166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47167 if (!SWIG_IsOK(res2)) {
47168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47169 }
47170 arg2 = reinterpret_cast< wxWindow * >(argp2);
47171 {
47172 PyThreadState* __tstate = wxPyBeginAllowThreads();
47173 (arg1)->SetVirtualSizeHints(arg2);
47174 wxPyEndAllowThreads(__tstate);
47175 if (PyErr_Occurred()) SWIG_fail;
47176 }
47177 resultobj = SWIG_Py_Void();
47178 return resultobj;
47179 fail:
47180 return NULL;
47181 }
47182
47183
47184 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47185 PyObject *resultobj = 0;
47186 wxSizer *arg1 = (wxSizer *) 0 ;
47187 bool arg2 = (bool) false ;
47188 void *argp1 = 0 ;
47189 int res1 = 0 ;
47190 bool val2 ;
47191 int ecode2 = 0 ;
47192 PyObject * obj0 = 0 ;
47193 PyObject * obj1 = 0 ;
47194 char * kwnames[] = {
47195 (char *) "self",(char *) "deleteWindows", NULL
47196 };
47197
47198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47200 if (!SWIG_IsOK(res1)) {
47201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47202 }
47203 arg1 = reinterpret_cast< wxSizer * >(argp1);
47204 if (obj1) {
47205 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47206 if (!SWIG_IsOK(ecode2)) {
47207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47208 }
47209 arg2 = static_cast< bool >(val2);
47210 }
47211 {
47212 PyThreadState* __tstate = wxPyBeginAllowThreads();
47213 (arg1)->Clear(arg2);
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_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47225 PyObject *resultobj = 0;
47226 wxSizer *arg1 = (wxSizer *) 0 ;
47227 void *argp1 = 0 ;
47228 int res1 = 0 ;
47229 PyObject *swig_obj[1] ;
47230
47231 if (!args) SWIG_fail;
47232 swig_obj[0] = args;
47233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47234 if (!SWIG_IsOK(res1)) {
47235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47236 }
47237 arg1 = reinterpret_cast< wxSizer * >(argp1);
47238 {
47239 PyThreadState* __tstate = wxPyBeginAllowThreads();
47240 (arg1)->DeleteWindows();
47241 wxPyEndAllowThreads(__tstate);
47242 if (PyErr_Occurred()) SWIG_fail;
47243 }
47244 resultobj = SWIG_Py_Void();
47245 return resultobj;
47246 fail:
47247 return NULL;
47248 }
47249
47250
47251 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47252 PyObject *resultobj = 0;
47253 wxSizer *arg1 = (wxSizer *) 0 ;
47254 PyObject *result = 0 ;
47255 void *argp1 = 0 ;
47256 int res1 = 0 ;
47257 PyObject *swig_obj[1] ;
47258
47259 if (!args) SWIG_fail;
47260 swig_obj[0] = args;
47261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47262 if (!SWIG_IsOK(res1)) {
47263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47264 }
47265 arg1 = reinterpret_cast< wxSizer * >(argp1);
47266 {
47267 PyThreadState* __tstate = wxPyBeginAllowThreads();
47268 result = (PyObject *)wxSizer_GetChildren(arg1);
47269 wxPyEndAllowThreads(__tstate);
47270 if (PyErr_Occurred()) SWIG_fail;
47271 }
47272 resultobj = result;
47273 return resultobj;
47274 fail:
47275 return NULL;
47276 }
47277
47278
47279 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47280 PyObject *resultobj = 0;
47281 wxSizer *arg1 = (wxSizer *) 0 ;
47282 PyObject *arg2 = (PyObject *) 0 ;
47283 bool arg3 = (bool) true ;
47284 bool arg4 = (bool) false ;
47285 bool result;
47286 void *argp1 = 0 ;
47287 int res1 = 0 ;
47288 bool val3 ;
47289 int ecode3 = 0 ;
47290 bool val4 ;
47291 int ecode4 = 0 ;
47292 PyObject * obj0 = 0 ;
47293 PyObject * obj1 = 0 ;
47294 PyObject * obj2 = 0 ;
47295 PyObject * obj3 = 0 ;
47296 char * kwnames[] = {
47297 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47298 };
47299
47300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47302 if (!SWIG_IsOK(res1)) {
47303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47304 }
47305 arg1 = reinterpret_cast< wxSizer * >(argp1);
47306 arg2 = obj1;
47307 if (obj2) {
47308 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47309 if (!SWIG_IsOK(ecode3)) {
47310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47311 }
47312 arg3 = static_cast< bool >(val3);
47313 }
47314 if (obj3) {
47315 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47316 if (!SWIG_IsOK(ecode4)) {
47317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47318 }
47319 arg4 = static_cast< bool >(val4);
47320 }
47321 {
47322 PyThreadState* __tstate = wxPyBeginAllowThreads();
47323 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47324 wxPyEndAllowThreads(__tstate);
47325 if (PyErr_Occurred()) SWIG_fail;
47326 }
47327 {
47328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47329 }
47330 return resultobj;
47331 fail:
47332 return NULL;
47333 }
47334
47335
47336 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47337 PyObject *resultobj = 0;
47338 wxSizer *arg1 = (wxSizer *) 0 ;
47339 PyObject *arg2 = (PyObject *) 0 ;
47340 bool result;
47341 void *argp1 = 0 ;
47342 int res1 = 0 ;
47343 PyObject * obj0 = 0 ;
47344 PyObject * obj1 = 0 ;
47345 char * kwnames[] = {
47346 (char *) "self",(char *) "item", NULL
47347 };
47348
47349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47351 if (!SWIG_IsOK(res1)) {
47352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47353 }
47354 arg1 = reinterpret_cast< wxSizer * >(argp1);
47355 arg2 = obj1;
47356 {
47357 PyThreadState* __tstate = wxPyBeginAllowThreads();
47358 result = (bool)wxSizer_IsShown(arg1,arg2);
47359 wxPyEndAllowThreads(__tstate);
47360 if (PyErr_Occurred()) SWIG_fail;
47361 }
47362 {
47363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47364 }
47365 return resultobj;
47366 fail:
47367 return NULL;
47368 }
47369
47370
47371 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47372 PyObject *resultobj = 0;
47373 wxSizer *arg1 = (wxSizer *) 0 ;
47374 bool arg2 ;
47375 void *argp1 = 0 ;
47376 int res1 = 0 ;
47377 bool val2 ;
47378 int ecode2 = 0 ;
47379 PyObject * obj0 = 0 ;
47380 PyObject * obj1 = 0 ;
47381 char * kwnames[] = {
47382 (char *) "self",(char *) "show", NULL
47383 };
47384
47385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47387 if (!SWIG_IsOK(res1)) {
47388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47389 }
47390 arg1 = reinterpret_cast< wxSizer * >(argp1);
47391 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47392 if (!SWIG_IsOK(ecode2)) {
47393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47394 }
47395 arg2 = static_cast< bool >(val2);
47396 {
47397 PyThreadState* __tstate = wxPyBeginAllowThreads();
47398 (arg1)->ShowItems(arg2);
47399 wxPyEndAllowThreads(__tstate);
47400 if (PyErr_Occurred()) SWIG_fail;
47401 }
47402 resultobj = SWIG_Py_Void();
47403 return resultobj;
47404 fail:
47405 return NULL;
47406 }
47407
47408
47409 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47410 PyObject *obj;
47411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47412 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47413 return SWIG_Py_Void();
47414 }
47415
47416 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47417 PyObject *resultobj = 0;
47418 wxPySizer *result = 0 ;
47419
47420 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47421 {
47422 PyThreadState* __tstate = wxPyBeginAllowThreads();
47423 result = (wxPySizer *)new wxPySizer();
47424 wxPyEndAllowThreads(__tstate);
47425 if (PyErr_Occurred()) SWIG_fail;
47426 }
47427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47428 return resultobj;
47429 fail:
47430 return NULL;
47431 }
47432
47433
47434 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47435 PyObject *resultobj = 0;
47436 wxPySizer *arg1 = (wxPySizer *) 0 ;
47437 PyObject *arg2 = (PyObject *) 0 ;
47438 PyObject *arg3 = (PyObject *) 0 ;
47439 void *argp1 = 0 ;
47440 int res1 = 0 ;
47441 PyObject * obj0 = 0 ;
47442 PyObject * obj1 = 0 ;
47443 PyObject * obj2 = 0 ;
47444 char * kwnames[] = {
47445 (char *) "self",(char *) "self",(char *) "_class", NULL
47446 };
47447
47448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47450 if (!SWIG_IsOK(res1)) {
47451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47452 }
47453 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47454 arg2 = obj1;
47455 arg3 = obj2;
47456 {
47457 PyThreadState* __tstate = wxPyBeginAllowThreads();
47458 (arg1)->_setCallbackInfo(arg2,arg3);
47459 wxPyEndAllowThreads(__tstate);
47460 if (PyErr_Occurred()) SWIG_fail;
47461 }
47462 resultobj = SWIG_Py_Void();
47463 return resultobj;
47464 fail:
47465 return NULL;
47466 }
47467
47468
47469 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47470 PyObject *obj;
47471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47472 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47473 return SWIG_Py_Void();
47474 }
47475
47476 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47477 return SWIG_Python_InitShadowInstance(args);
47478 }
47479
47480 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47481 PyObject *resultobj = 0;
47482 int arg1 = (int) wxHORIZONTAL ;
47483 wxBoxSizer *result = 0 ;
47484 int val1 ;
47485 int ecode1 = 0 ;
47486 PyObject * obj0 = 0 ;
47487 char * kwnames[] = {
47488 (char *) "orient", NULL
47489 };
47490
47491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47492 if (obj0) {
47493 ecode1 = SWIG_AsVal_int(obj0, &val1);
47494 if (!SWIG_IsOK(ecode1)) {
47495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47496 }
47497 arg1 = static_cast< int >(val1);
47498 }
47499 {
47500 PyThreadState* __tstate = wxPyBeginAllowThreads();
47501 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47502 wxPyEndAllowThreads(__tstate);
47503 if (PyErr_Occurred()) SWIG_fail;
47504 }
47505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47506 return resultobj;
47507 fail:
47508 return NULL;
47509 }
47510
47511
47512 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47513 PyObject *resultobj = 0;
47514 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47515 int result;
47516 void *argp1 = 0 ;
47517 int res1 = 0 ;
47518 PyObject *swig_obj[1] ;
47519
47520 if (!args) SWIG_fail;
47521 swig_obj[0] = args;
47522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47523 if (!SWIG_IsOK(res1)) {
47524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47525 }
47526 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47527 {
47528 PyThreadState* __tstate = wxPyBeginAllowThreads();
47529 result = (int)(arg1)->GetOrientation();
47530 wxPyEndAllowThreads(__tstate);
47531 if (PyErr_Occurred()) SWIG_fail;
47532 }
47533 resultobj = SWIG_From_int(static_cast< int >(result));
47534 return resultobj;
47535 fail:
47536 return NULL;
47537 }
47538
47539
47540 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47541 PyObject *resultobj = 0;
47542 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47543 int arg2 ;
47544 void *argp1 = 0 ;
47545 int res1 = 0 ;
47546 int val2 ;
47547 int ecode2 = 0 ;
47548 PyObject * obj0 = 0 ;
47549 PyObject * obj1 = 0 ;
47550 char * kwnames[] = {
47551 (char *) "self",(char *) "orient", NULL
47552 };
47553
47554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47556 if (!SWIG_IsOK(res1)) {
47557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47558 }
47559 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47560 ecode2 = SWIG_AsVal_int(obj1, &val2);
47561 if (!SWIG_IsOK(ecode2)) {
47562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47563 }
47564 arg2 = static_cast< int >(val2);
47565 {
47566 PyThreadState* __tstate = wxPyBeginAllowThreads();
47567 (arg1)->SetOrientation(arg2);
47568 wxPyEndAllowThreads(__tstate);
47569 if (PyErr_Occurred()) SWIG_fail;
47570 }
47571 resultobj = SWIG_Py_Void();
47572 return resultobj;
47573 fail:
47574 return NULL;
47575 }
47576
47577
47578 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47579 PyObject *obj;
47580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47581 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47582 return SWIG_Py_Void();
47583 }
47584
47585 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47586 return SWIG_Python_InitShadowInstance(args);
47587 }
47588
47589 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47590 PyObject *resultobj = 0;
47591 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47592 int arg2 = (int) wxHORIZONTAL ;
47593 wxStaticBoxSizer *result = 0 ;
47594 void *argp1 = 0 ;
47595 int res1 = 0 ;
47596 int val2 ;
47597 int ecode2 = 0 ;
47598 PyObject * obj0 = 0 ;
47599 PyObject * obj1 = 0 ;
47600 char * kwnames[] = {
47601 (char *) "box",(char *) "orient", NULL
47602 };
47603
47604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47606 if (!SWIG_IsOK(res1)) {
47607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47608 }
47609 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47610 if (obj1) {
47611 ecode2 = SWIG_AsVal_int(obj1, &val2);
47612 if (!SWIG_IsOK(ecode2)) {
47613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47614 }
47615 arg2 = static_cast< int >(val2);
47616 }
47617 {
47618 PyThreadState* __tstate = wxPyBeginAllowThreads();
47619 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47620 wxPyEndAllowThreads(__tstate);
47621 if (PyErr_Occurred()) SWIG_fail;
47622 }
47623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47624 return resultobj;
47625 fail:
47626 return NULL;
47627 }
47628
47629
47630 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47631 PyObject *resultobj = 0;
47632 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47633 wxStaticBox *result = 0 ;
47634 void *argp1 = 0 ;
47635 int res1 = 0 ;
47636 PyObject *swig_obj[1] ;
47637
47638 if (!args) SWIG_fail;
47639 swig_obj[0] = args;
47640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47641 if (!SWIG_IsOK(res1)) {
47642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47643 }
47644 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47645 {
47646 PyThreadState* __tstate = wxPyBeginAllowThreads();
47647 result = (wxStaticBox *)(arg1)->GetStaticBox();
47648 wxPyEndAllowThreads(__tstate);
47649 if (PyErr_Occurred()) SWIG_fail;
47650 }
47651 {
47652 resultobj = wxPyMake_wxObject(result, (bool)0);
47653 }
47654 return resultobj;
47655 fail:
47656 return NULL;
47657 }
47658
47659
47660 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47661 PyObject *obj;
47662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47663 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47664 return SWIG_Py_Void();
47665 }
47666
47667 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47668 return SWIG_Python_InitShadowInstance(args);
47669 }
47670
47671 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47672 PyObject *resultobj = 0;
47673 int arg1 = (int) 1 ;
47674 int arg2 = (int) 0 ;
47675 int arg3 = (int) 0 ;
47676 int arg4 = (int) 0 ;
47677 wxGridSizer *result = 0 ;
47678 int val1 ;
47679 int ecode1 = 0 ;
47680 int val2 ;
47681 int ecode2 = 0 ;
47682 int val3 ;
47683 int ecode3 = 0 ;
47684 int val4 ;
47685 int ecode4 = 0 ;
47686 PyObject * obj0 = 0 ;
47687 PyObject * obj1 = 0 ;
47688 PyObject * obj2 = 0 ;
47689 PyObject * obj3 = 0 ;
47690 char * kwnames[] = {
47691 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47692 };
47693
47694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47695 if (obj0) {
47696 ecode1 = SWIG_AsVal_int(obj0, &val1);
47697 if (!SWIG_IsOK(ecode1)) {
47698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47699 }
47700 arg1 = static_cast< int >(val1);
47701 }
47702 if (obj1) {
47703 ecode2 = SWIG_AsVal_int(obj1, &val2);
47704 if (!SWIG_IsOK(ecode2)) {
47705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47706 }
47707 arg2 = static_cast< int >(val2);
47708 }
47709 if (obj2) {
47710 ecode3 = SWIG_AsVal_int(obj2, &val3);
47711 if (!SWIG_IsOK(ecode3)) {
47712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47713 }
47714 arg3 = static_cast< int >(val3);
47715 }
47716 if (obj3) {
47717 ecode4 = SWIG_AsVal_int(obj3, &val4);
47718 if (!SWIG_IsOK(ecode4)) {
47719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47720 }
47721 arg4 = static_cast< int >(val4);
47722 }
47723 {
47724 PyThreadState* __tstate = wxPyBeginAllowThreads();
47725 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47726 wxPyEndAllowThreads(__tstate);
47727 if (PyErr_Occurred()) SWIG_fail;
47728 }
47729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47730 return resultobj;
47731 fail:
47732 return NULL;
47733 }
47734
47735
47736 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47737 PyObject *resultobj = 0;
47738 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47739 int arg2 ;
47740 void *argp1 = 0 ;
47741 int res1 = 0 ;
47742 int val2 ;
47743 int ecode2 = 0 ;
47744 PyObject * obj0 = 0 ;
47745 PyObject * obj1 = 0 ;
47746 char * kwnames[] = {
47747 (char *) "self",(char *) "cols", NULL
47748 };
47749
47750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47752 if (!SWIG_IsOK(res1)) {
47753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47754 }
47755 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47756 ecode2 = SWIG_AsVal_int(obj1, &val2);
47757 if (!SWIG_IsOK(ecode2)) {
47758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47759 }
47760 arg2 = static_cast< int >(val2);
47761 {
47762 PyThreadState* __tstate = wxPyBeginAllowThreads();
47763 (arg1)->SetCols(arg2);
47764 wxPyEndAllowThreads(__tstate);
47765 if (PyErr_Occurred()) SWIG_fail;
47766 }
47767 resultobj = SWIG_Py_Void();
47768 return resultobj;
47769 fail:
47770 return NULL;
47771 }
47772
47773
47774 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47775 PyObject *resultobj = 0;
47776 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47777 int arg2 ;
47778 void *argp1 = 0 ;
47779 int res1 = 0 ;
47780 int val2 ;
47781 int ecode2 = 0 ;
47782 PyObject * obj0 = 0 ;
47783 PyObject * obj1 = 0 ;
47784 char * kwnames[] = {
47785 (char *) "self",(char *) "rows", NULL
47786 };
47787
47788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47790 if (!SWIG_IsOK(res1)) {
47791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47792 }
47793 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47794 ecode2 = SWIG_AsVal_int(obj1, &val2);
47795 if (!SWIG_IsOK(ecode2)) {
47796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47797 }
47798 arg2 = static_cast< int >(val2);
47799 {
47800 PyThreadState* __tstate = wxPyBeginAllowThreads();
47801 (arg1)->SetRows(arg2);
47802 wxPyEndAllowThreads(__tstate);
47803 if (PyErr_Occurred()) SWIG_fail;
47804 }
47805 resultobj = SWIG_Py_Void();
47806 return resultobj;
47807 fail:
47808 return NULL;
47809 }
47810
47811
47812 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47813 PyObject *resultobj = 0;
47814 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47815 int arg2 ;
47816 void *argp1 = 0 ;
47817 int res1 = 0 ;
47818 int val2 ;
47819 int ecode2 = 0 ;
47820 PyObject * obj0 = 0 ;
47821 PyObject * obj1 = 0 ;
47822 char * kwnames[] = {
47823 (char *) "self",(char *) "gap", NULL
47824 };
47825
47826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47828 if (!SWIG_IsOK(res1)) {
47829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47830 }
47831 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47832 ecode2 = SWIG_AsVal_int(obj1, &val2);
47833 if (!SWIG_IsOK(ecode2)) {
47834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47835 }
47836 arg2 = static_cast< int >(val2);
47837 {
47838 PyThreadState* __tstate = wxPyBeginAllowThreads();
47839 (arg1)->SetVGap(arg2);
47840 wxPyEndAllowThreads(__tstate);
47841 if (PyErr_Occurred()) SWIG_fail;
47842 }
47843 resultobj = SWIG_Py_Void();
47844 return resultobj;
47845 fail:
47846 return NULL;
47847 }
47848
47849
47850 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47851 PyObject *resultobj = 0;
47852 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47853 int arg2 ;
47854 void *argp1 = 0 ;
47855 int res1 = 0 ;
47856 int val2 ;
47857 int ecode2 = 0 ;
47858 PyObject * obj0 = 0 ;
47859 PyObject * obj1 = 0 ;
47860 char * kwnames[] = {
47861 (char *) "self",(char *) "gap", NULL
47862 };
47863
47864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47866 if (!SWIG_IsOK(res1)) {
47867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47868 }
47869 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47870 ecode2 = SWIG_AsVal_int(obj1, &val2);
47871 if (!SWIG_IsOK(ecode2)) {
47872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47873 }
47874 arg2 = static_cast< int >(val2);
47875 {
47876 PyThreadState* __tstate = wxPyBeginAllowThreads();
47877 (arg1)->SetHGap(arg2);
47878 wxPyEndAllowThreads(__tstate);
47879 if (PyErr_Occurred()) SWIG_fail;
47880 }
47881 resultobj = SWIG_Py_Void();
47882 return resultobj;
47883 fail:
47884 return NULL;
47885 }
47886
47887
47888 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47889 PyObject *resultobj = 0;
47890 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47891 int result;
47892 void *argp1 = 0 ;
47893 int res1 = 0 ;
47894 PyObject *swig_obj[1] ;
47895
47896 if (!args) SWIG_fail;
47897 swig_obj[0] = args;
47898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47899 if (!SWIG_IsOK(res1)) {
47900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47901 }
47902 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47903 {
47904 PyThreadState* __tstate = wxPyBeginAllowThreads();
47905 result = (int)(arg1)->GetCols();
47906 wxPyEndAllowThreads(__tstate);
47907 if (PyErr_Occurred()) SWIG_fail;
47908 }
47909 resultobj = SWIG_From_int(static_cast< int >(result));
47910 return resultobj;
47911 fail:
47912 return NULL;
47913 }
47914
47915
47916 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47917 PyObject *resultobj = 0;
47918 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47919 int result;
47920 void *argp1 = 0 ;
47921 int res1 = 0 ;
47922 PyObject *swig_obj[1] ;
47923
47924 if (!args) SWIG_fail;
47925 swig_obj[0] = args;
47926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47927 if (!SWIG_IsOK(res1)) {
47928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47929 }
47930 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47931 {
47932 PyThreadState* __tstate = wxPyBeginAllowThreads();
47933 result = (int)(arg1)->GetRows();
47934 wxPyEndAllowThreads(__tstate);
47935 if (PyErr_Occurred()) SWIG_fail;
47936 }
47937 resultobj = SWIG_From_int(static_cast< int >(result));
47938 return resultobj;
47939 fail:
47940 return NULL;
47941 }
47942
47943
47944 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47945 PyObject *resultobj = 0;
47946 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47947 int result;
47948 void *argp1 = 0 ;
47949 int res1 = 0 ;
47950 PyObject *swig_obj[1] ;
47951
47952 if (!args) SWIG_fail;
47953 swig_obj[0] = args;
47954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47955 if (!SWIG_IsOK(res1)) {
47956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47957 }
47958 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47959 {
47960 PyThreadState* __tstate = wxPyBeginAllowThreads();
47961 result = (int)(arg1)->GetVGap();
47962 wxPyEndAllowThreads(__tstate);
47963 if (PyErr_Occurred()) SWIG_fail;
47964 }
47965 resultobj = SWIG_From_int(static_cast< int >(result));
47966 return resultobj;
47967 fail:
47968 return NULL;
47969 }
47970
47971
47972 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47973 PyObject *resultobj = 0;
47974 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47975 int result;
47976 void *argp1 = 0 ;
47977 int res1 = 0 ;
47978 PyObject *swig_obj[1] ;
47979
47980 if (!args) SWIG_fail;
47981 swig_obj[0] = args;
47982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47983 if (!SWIG_IsOK(res1)) {
47984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47985 }
47986 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47987 {
47988 PyThreadState* __tstate = wxPyBeginAllowThreads();
47989 result = (int)(arg1)->GetHGap();
47990 wxPyEndAllowThreads(__tstate);
47991 if (PyErr_Occurred()) SWIG_fail;
47992 }
47993 resultobj = SWIG_From_int(static_cast< int >(result));
47994 return resultobj;
47995 fail:
47996 return NULL;
47997 }
47998
47999
48000 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48001 PyObject *obj;
48002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48003 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48004 return SWIG_Py_Void();
48005 }
48006
48007 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48008 return SWIG_Python_InitShadowInstance(args);
48009 }
48010
48011 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48012 PyObject *resultobj = 0;
48013 int arg1 = (int) 1 ;
48014 int arg2 = (int) 0 ;
48015 int arg3 = (int) 0 ;
48016 int arg4 = (int) 0 ;
48017 wxFlexGridSizer *result = 0 ;
48018 int val1 ;
48019 int ecode1 = 0 ;
48020 int val2 ;
48021 int ecode2 = 0 ;
48022 int val3 ;
48023 int ecode3 = 0 ;
48024 int val4 ;
48025 int ecode4 = 0 ;
48026 PyObject * obj0 = 0 ;
48027 PyObject * obj1 = 0 ;
48028 PyObject * obj2 = 0 ;
48029 PyObject * obj3 = 0 ;
48030 char * kwnames[] = {
48031 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48032 };
48033
48034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48035 if (obj0) {
48036 ecode1 = SWIG_AsVal_int(obj0, &val1);
48037 if (!SWIG_IsOK(ecode1)) {
48038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48039 }
48040 arg1 = static_cast< int >(val1);
48041 }
48042 if (obj1) {
48043 ecode2 = SWIG_AsVal_int(obj1, &val2);
48044 if (!SWIG_IsOK(ecode2)) {
48045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48046 }
48047 arg2 = static_cast< int >(val2);
48048 }
48049 if (obj2) {
48050 ecode3 = SWIG_AsVal_int(obj2, &val3);
48051 if (!SWIG_IsOK(ecode3)) {
48052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48053 }
48054 arg3 = static_cast< int >(val3);
48055 }
48056 if (obj3) {
48057 ecode4 = SWIG_AsVal_int(obj3, &val4);
48058 if (!SWIG_IsOK(ecode4)) {
48059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48060 }
48061 arg4 = static_cast< int >(val4);
48062 }
48063 {
48064 PyThreadState* __tstate = wxPyBeginAllowThreads();
48065 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48066 wxPyEndAllowThreads(__tstate);
48067 if (PyErr_Occurred()) SWIG_fail;
48068 }
48069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48070 return resultobj;
48071 fail:
48072 return NULL;
48073 }
48074
48075
48076 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48077 PyObject *resultobj = 0;
48078 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48079 size_t arg2 ;
48080 int arg3 = (int) 0 ;
48081 void *argp1 = 0 ;
48082 int res1 = 0 ;
48083 size_t val2 ;
48084 int ecode2 = 0 ;
48085 int val3 ;
48086 int ecode3 = 0 ;
48087 PyObject * obj0 = 0 ;
48088 PyObject * obj1 = 0 ;
48089 PyObject * obj2 = 0 ;
48090 char * kwnames[] = {
48091 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48092 };
48093
48094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48096 if (!SWIG_IsOK(res1)) {
48097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48098 }
48099 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48100 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48101 if (!SWIG_IsOK(ecode2)) {
48102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48103 }
48104 arg2 = static_cast< size_t >(val2);
48105 if (obj2) {
48106 ecode3 = SWIG_AsVal_int(obj2, &val3);
48107 if (!SWIG_IsOK(ecode3)) {
48108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48109 }
48110 arg3 = static_cast< int >(val3);
48111 }
48112 {
48113 PyThreadState* __tstate = wxPyBeginAllowThreads();
48114 (arg1)->AddGrowableRow(arg2,arg3);
48115 wxPyEndAllowThreads(__tstate);
48116 if (PyErr_Occurred()) SWIG_fail;
48117 }
48118 resultobj = SWIG_Py_Void();
48119 return resultobj;
48120 fail:
48121 return NULL;
48122 }
48123
48124
48125 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48126 PyObject *resultobj = 0;
48127 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48128 size_t arg2 ;
48129 void *argp1 = 0 ;
48130 int res1 = 0 ;
48131 size_t val2 ;
48132 int ecode2 = 0 ;
48133 PyObject * obj0 = 0 ;
48134 PyObject * obj1 = 0 ;
48135 char * kwnames[] = {
48136 (char *) "self",(char *) "idx", NULL
48137 };
48138
48139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48141 if (!SWIG_IsOK(res1)) {
48142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48143 }
48144 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48145 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48146 if (!SWIG_IsOK(ecode2)) {
48147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48148 }
48149 arg2 = static_cast< size_t >(val2);
48150 {
48151 PyThreadState* __tstate = wxPyBeginAllowThreads();
48152 (arg1)->RemoveGrowableRow(arg2);
48153 wxPyEndAllowThreads(__tstate);
48154 if (PyErr_Occurred()) SWIG_fail;
48155 }
48156 resultobj = SWIG_Py_Void();
48157 return resultobj;
48158 fail:
48159 return NULL;
48160 }
48161
48162
48163 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48164 PyObject *resultobj = 0;
48165 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48166 size_t arg2 ;
48167 int arg3 = (int) 0 ;
48168 void *argp1 = 0 ;
48169 int res1 = 0 ;
48170 size_t val2 ;
48171 int ecode2 = 0 ;
48172 int val3 ;
48173 int ecode3 = 0 ;
48174 PyObject * obj0 = 0 ;
48175 PyObject * obj1 = 0 ;
48176 PyObject * obj2 = 0 ;
48177 char * kwnames[] = {
48178 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48179 };
48180
48181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48183 if (!SWIG_IsOK(res1)) {
48184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48185 }
48186 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48187 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48188 if (!SWIG_IsOK(ecode2)) {
48189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48190 }
48191 arg2 = static_cast< size_t >(val2);
48192 if (obj2) {
48193 ecode3 = SWIG_AsVal_int(obj2, &val3);
48194 if (!SWIG_IsOK(ecode3)) {
48195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48196 }
48197 arg3 = static_cast< int >(val3);
48198 }
48199 {
48200 PyThreadState* __tstate = wxPyBeginAllowThreads();
48201 (arg1)->AddGrowableCol(arg2,arg3);
48202 wxPyEndAllowThreads(__tstate);
48203 if (PyErr_Occurred()) SWIG_fail;
48204 }
48205 resultobj = SWIG_Py_Void();
48206 return resultobj;
48207 fail:
48208 return NULL;
48209 }
48210
48211
48212 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48213 PyObject *resultobj = 0;
48214 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48215 size_t arg2 ;
48216 void *argp1 = 0 ;
48217 int res1 = 0 ;
48218 size_t val2 ;
48219 int ecode2 = 0 ;
48220 PyObject * obj0 = 0 ;
48221 PyObject * obj1 = 0 ;
48222 char * kwnames[] = {
48223 (char *) "self",(char *) "idx", NULL
48224 };
48225
48226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48228 if (!SWIG_IsOK(res1)) {
48229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48230 }
48231 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48232 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48233 if (!SWIG_IsOK(ecode2)) {
48234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48235 }
48236 arg2 = static_cast< size_t >(val2);
48237 {
48238 PyThreadState* __tstate = wxPyBeginAllowThreads();
48239 (arg1)->RemoveGrowableCol(arg2);
48240 wxPyEndAllowThreads(__tstate);
48241 if (PyErr_Occurred()) SWIG_fail;
48242 }
48243 resultobj = SWIG_Py_Void();
48244 return resultobj;
48245 fail:
48246 return NULL;
48247 }
48248
48249
48250 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48251 PyObject *resultobj = 0;
48252 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48253 int arg2 ;
48254 void *argp1 = 0 ;
48255 int res1 = 0 ;
48256 int val2 ;
48257 int ecode2 = 0 ;
48258 PyObject * obj0 = 0 ;
48259 PyObject * obj1 = 0 ;
48260 char * kwnames[] = {
48261 (char *) "self",(char *) "direction", NULL
48262 };
48263
48264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48266 if (!SWIG_IsOK(res1)) {
48267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48268 }
48269 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48270 ecode2 = SWIG_AsVal_int(obj1, &val2);
48271 if (!SWIG_IsOK(ecode2)) {
48272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48273 }
48274 arg2 = static_cast< int >(val2);
48275 {
48276 PyThreadState* __tstate = wxPyBeginAllowThreads();
48277 (arg1)->SetFlexibleDirection(arg2);
48278 wxPyEndAllowThreads(__tstate);
48279 if (PyErr_Occurred()) SWIG_fail;
48280 }
48281 resultobj = SWIG_Py_Void();
48282 return resultobj;
48283 fail:
48284 return NULL;
48285 }
48286
48287
48288 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48289 PyObject *resultobj = 0;
48290 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48291 int result;
48292 void *argp1 = 0 ;
48293 int res1 = 0 ;
48294 PyObject *swig_obj[1] ;
48295
48296 if (!args) SWIG_fail;
48297 swig_obj[0] = args;
48298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48299 if (!SWIG_IsOK(res1)) {
48300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48301 }
48302 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48303 {
48304 PyThreadState* __tstate = wxPyBeginAllowThreads();
48305 result = (int)(arg1)->GetFlexibleDirection();
48306 wxPyEndAllowThreads(__tstate);
48307 if (PyErr_Occurred()) SWIG_fail;
48308 }
48309 resultobj = SWIG_From_int(static_cast< int >(result));
48310 return resultobj;
48311 fail:
48312 return NULL;
48313 }
48314
48315
48316 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48317 PyObject *resultobj = 0;
48318 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48319 wxFlexSizerGrowMode arg2 ;
48320 void *argp1 = 0 ;
48321 int res1 = 0 ;
48322 int val2 ;
48323 int ecode2 = 0 ;
48324 PyObject * obj0 = 0 ;
48325 PyObject * obj1 = 0 ;
48326 char * kwnames[] = {
48327 (char *) "self",(char *) "mode", NULL
48328 };
48329
48330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48332 if (!SWIG_IsOK(res1)) {
48333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48334 }
48335 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48336 ecode2 = SWIG_AsVal_int(obj1, &val2);
48337 if (!SWIG_IsOK(ecode2)) {
48338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48339 }
48340 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48341 {
48342 PyThreadState* __tstate = wxPyBeginAllowThreads();
48343 (arg1)->SetNonFlexibleGrowMode(arg2);
48344 wxPyEndAllowThreads(__tstate);
48345 if (PyErr_Occurred()) SWIG_fail;
48346 }
48347 resultobj = SWIG_Py_Void();
48348 return resultobj;
48349 fail:
48350 return NULL;
48351 }
48352
48353
48354 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48355 PyObject *resultobj = 0;
48356 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48357 wxFlexSizerGrowMode result;
48358 void *argp1 = 0 ;
48359 int res1 = 0 ;
48360 PyObject *swig_obj[1] ;
48361
48362 if (!args) SWIG_fail;
48363 swig_obj[0] = args;
48364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48365 if (!SWIG_IsOK(res1)) {
48366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48367 }
48368 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48369 {
48370 PyThreadState* __tstate = wxPyBeginAllowThreads();
48371 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48372 wxPyEndAllowThreads(__tstate);
48373 if (PyErr_Occurred()) SWIG_fail;
48374 }
48375 resultobj = SWIG_From_int(static_cast< int >(result));
48376 return resultobj;
48377 fail:
48378 return NULL;
48379 }
48380
48381
48382 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48383 PyObject *resultobj = 0;
48384 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48385 wxArrayInt *result = 0 ;
48386 void *argp1 = 0 ;
48387 int res1 = 0 ;
48388 PyObject *swig_obj[1] ;
48389
48390 if (!args) SWIG_fail;
48391 swig_obj[0] = args;
48392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48393 if (!SWIG_IsOK(res1)) {
48394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48395 }
48396 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48397 {
48398 PyThreadState* __tstate = wxPyBeginAllowThreads();
48399 {
48400 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48401 result = (wxArrayInt *) &_result_ref;
48402 }
48403 wxPyEndAllowThreads(__tstate);
48404 if (PyErr_Occurred()) SWIG_fail;
48405 }
48406 {
48407 resultobj = PyList_New(0);
48408 size_t idx;
48409 for (idx = 0; idx < result->GetCount(); idx += 1) {
48410 PyObject* val = PyInt_FromLong( result->Item(idx) );
48411 PyList_Append(resultobj, val);
48412 Py_DECREF(val);
48413 }
48414 }
48415 return resultobj;
48416 fail:
48417 return NULL;
48418 }
48419
48420
48421 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48422 PyObject *resultobj = 0;
48423 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48424 wxArrayInt *result = 0 ;
48425 void *argp1 = 0 ;
48426 int res1 = 0 ;
48427 PyObject *swig_obj[1] ;
48428
48429 if (!args) SWIG_fail;
48430 swig_obj[0] = args;
48431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48432 if (!SWIG_IsOK(res1)) {
48433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48434 }
48435 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48436 {
48437 PyThreadState* __tstate = wxPyBeginAllowThreads();
48438 {
48439 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48440 result = (wxArrayInt *) &_result_ref;
48441 }
48442 wxPyEndAllowThreads(__tstate);
48443 if (PyErr_Occurred()) SWIG_fail;
48444 }
48445 {
48446 resultobj = PyList_New(0);
48447 size_t idx;
48448 for (idx = 0; idx < result->GetCount(); idx += 1) {
48449 PyObject* val = PyInt_FromLong( result->Item(idx) );
48450 PyList_Append(resultobj, val);
48451 Py_DECREF(val);
48452 }
48453 }
48454 return resultobj;
48455 fail:
48456 return NULL;
48457 }
48458
48459
48460 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48461 PyObject *obj;
48462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48463 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48464 return SWIG_Py_Void();
48465 }
48466
48467 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48468 return SWIG_Python_InitShadowInstance(args);
48469 }
48470
48471 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48472 PyObject *resultobj = 0;
48473 wxStdDialogButtonSizer *result = 0 ;
48474
48475 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48476 {
48477 PyThreadState* __tstate = wxPyBeginAllowThreads();
48478 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48479 wxPyEndAllowThreads(__tstate);
48480 if (PyErr_Occurred()) SWIG_fail;
48481 }
48482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48483 return resultobj;
48484 fail:
48485 return NULL;
48486 }
48487
48488
48489 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48490 PyObject *resultobj = 0;
48491 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48492 wxButton *arg2 = (wxButton *) 0 ;
48493 void *argp1 = 0 ;
48494 int res1 = 0 ;
48495 void *argp2 = 0 ;
48496 int res2 = 0 ;
48497 PyObject * obj0 = 0 ;
48498 PyObject * obj1 = 0 ;
48499 char * kwnames[] = {
48500 (char *) "self",(char *) "button", NULL
48501 };
48502
48503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48505 if (!SWIG_IsOK(res1)) {
48506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48507 }
48508 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48510 if (!SWIG_IsOK(res2)) {
48511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48512 }
48513 arg2 = reinterpret_cast< wxButton * >(argp2);
48514 {
48515 PyThreadState* __tstate = wxPyBeginAllowThreads();
48516 (arg1)->AddButton(arg2);
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_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48528 PyObject *resultobj = 0;
48529 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48530 void *argp1 = 0 ;
48531 int res1 = 0 ;
48532 PyObject *swig_obj[1] ;
48533
48534 if (!args) SWIG_fail;
48535 swig_obj[0] = args;
48536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48537 if (!SWIG_IsOK(res1)) {
48538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48539 }
48540 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48541 {
48542 PyThreadState* __tstate = wxPyBeginAllowThreads();
48543 (arg1)->Realize();
48544 wxPyEndAllowThreads(__tstate);
48545 if (PyErr_Occurred()) SWIG_fail;
48546 }
48547 resultobj = SWIG_Py_Void();
48548 return resultobj;
48549 fail:
48550 return NULL;
48551 }
48552
48553
48554 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48555 PyObject *resultobj = 0;
48556 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48557 wxButton *arg2 = (wxButton *) 0 ;
48558 void *argp1 = 0 ;
48559 int res1 = 0 ;
48560 void *argp2 = 0 ;
48561 int res2 = 0 ;
48562 PyObject * obj0 = 0 ;
48563 PyObject * obj1 = 0 ;
48564 char * kwnames[] = {
48565 (char *) "self",(char *) "button", NULL
48566 };
48567
48568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48570 if (!SWIG_IsOK(res1)) {
48571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48572 }
48573 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48575 if (!SWIG_IsOK(res2)) {
48576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48577 }
48578 arg2 = reinterpret_cast< wxButton * >(argp2);
48579 {
48580 PyThreadState* __tstate = wxPyBeginAllowThreads();
48581 (arg1)->SetAffirmativeButton(arg2);
48582 wxPyEndAllowThreads(__tstate);
48583 if (PyErr_Occurred()) SWIG_fail;
48584 }
48585 resultobj = SWIG_Py_Void();
48586 return resultobj;
48587 fail:
48588 return NULL;
48589 }
48590
48591
48592 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48593 PyObject *resultobj = 0;
48594 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48595 wxButton *arg2 = (wxButton *) 0 ;
48596 void *argp1 = 0 ;
48597 int res1 = 0 ;
48598 void *argp2 = 0 ;
48599 int res2 = 0 ;
48600 PyObject * obj0 = 0 ;
48601 PyObject * obj1 = 0 ;
48602 char * kwnames[] = {
48603 (char *) "self",(char *) "button", NULL
48604 };
48605
48606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48608 if (!SWIG_IsOK(res1)) {
48609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48610 }
48611 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48613 if (!SWIG_IsOK(res2)) {
48614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48615 }
48616 arg2 = reinterpret_cast< wxButton * >(argp2);
48617 {
48618 PyThreadState* __tstate = wxPyBeginAllowThreads();
48619 (arg1)->SetNegativeButton(arg2);
48620 wxPyEndAllowThreads(__tstate);
48621 if (PyErr_Occurred()) SWIG_fail;
48622 }
48623 resultobj = SWIG_Py_Void();
48624 return resultobj;
48625 fail:
48626 return NULL;
48627 }
48628
48629
48630 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48631 PyObject *resultobj = 0;
48632 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48633 wxButton *arg2 = (wxButton *) 0 ;
48634 void *argp1 = 0 ;
48635 int res1 = 0 ;
48636 void *argp2 = 0 ;
48637 int res2 = 0 ;
48638 PyObject * obj0 = 0 ;
48639 PyObject * obj1 = 0 ;
48640 char * kwnames[] = {
48641 (char *) "self",(char *) "button", NULL
48642 };
48643
48644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48646 if (!SWIG_IsOK(res1)) {
48647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48648 }
48649 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48651 if (!SWIG_IsOK(res2)) {
48652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48653 }
48654 arg2 = reinterpret_cast< wxButton * >(argp2);
48655 {
48656 PyThreadState* __tstate = wxPyBeginAllowThreads();
48657 (arg1)->SetCancelButton(arg2);
48658 wxPyEndAllowThreads(__tstate);
48659 if (PyErr_Occurred()) SWIG_fail;
48660 }
48661 resultobj = SWIG_Py_Void();
48662 return resultobj;
48663 fail:
48664 return NULL;
48665 }
48666
48667
48668 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48669 PyObject *resultobj = 0;
48670 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48671 wxButton *result = 0 ;
48672 void *argp1 = 0 ;
48673 int res1 = 0 ;
48674 PyObject *swig_obj[1] ;
48675
48676 if (!args) SWIG_fail;
48677 swig_obj[0] = args;
48678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48679 if (!SWIG_IsOK(res1)) {
48680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48681 }
48682 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48683 {
48684 PyThreadState* __tstate = wxPyBeginAllowThreads();
48685 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48686 wxPyEndAllowThreads(__tstate);
48687 if (PyErr_Occurred()) SWIG_fail;
48688 }
48689 {
48690 resultobj = wxPyMake_wxObject(result, (bool)0);
48691 }
48692 return resultobj;
48693 fail:
48694 return NULL;
48695 }
48696
48697
48698 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48699 PyObject *resultobj = 0;
48700 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48701 wxButton *result = 0 ;
48702 void *argp1 = 0 ;
48703 int res1 = 0 ;
48704 PyObject *swig_obj[1] ;
48705
48706 if (!args) SWIG_fail;
48707 swig_obj[0] = args;
48708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48709 if (!SWIG_IsOK(res1)) {
48710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48711 }
48712 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48713 {
48714 PyThreadState* __tstate = wxPyBeginAllowThreads();
48715 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48716 wxPyEndAllowThreads(__tstate);
48717 if (PyErr_Occurred()) SWIG_fail;
48718 }
48719 {
48720 resultobj = wxPyMake_wxObject(result, (bool)0);
48721 }
48722 return resultobj;
48723 fail:
48724 return NULL;
48725 }
48726
48727
48728 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48729 PyObject *resultobj = 0;
48730 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48731 wxButton *result = 0 ;
48732 void *argp1 = 0 ;
48733 int res1 = 0 ;
48734 PyObject *swig_obj[1] ;
48735
48736 if (!args) SWIG_fail;
48737 swig_obj[0] = args;
48738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48739 if (!SWIG_IsOK(res1)) {
48740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48741 }
48742 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48743 {
48744 PyThreadState* __tstate = wxPyBeginAllowThreads();
48745 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48746 wxPyEndAllowThreads(__tstate);
48747 if (PyErr_Occurred()) SWIG_fail;
48748 }
48749 {
48750 resultobj = wxPyMake_wxObject(result, (bool)0);
48751 }
48752 return resultobj;
48753 fail:
48754 return NULL;
48755 }
48756
48757
48758 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48759 PyObject *resultobj = 0;
48760 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48761 wxButton *result = 0 ;
48762 void *argp1 = 0 ;
48763 int res1 = 0 ;
48764 PyObject *swig_obj[1] ;
48765
48766 if (!args) SWIG_fail;
48767 swig_obj[0] = args;
48768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48769 if (!SWIG_IsOK(res1)) {
48770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48771 }
48772 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48773 {
48774 PyThreadState* __tstate = wxPyBeginAllowThreads();
48775 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48776 wxPyEndAllowThreads(__tstate);
48777 if (PyErr_Occurred()) SWIG_fail;
48778 }
48779 {
48780 resultobj = wxPyMake_wxObject(result, (bool)0);
48781 }
48782 return resultobj;
48783 fail:
48784 return NULL;
48785 }
48786
48787
48788 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48789 PyObject *resultobj = 0;
48790 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48791 wxButton *result = 0 ;
48792 void *argp1 = 0 ;
48793 int res1 = 0 ;
48794 PyObject *swig_obj[1] ;
48795
48796 if (!args) SWIG_fail;
48797 swig_obj[0] = args;
48798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48799 if (!SWIG_IsOK(res1)) {
48800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48801 }
48802 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48803 {
48804 PyThreadState* __tstate = wxPyBeginAllowThreads();
48805 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48806 wxPyEndAllowThreads(__tstate);
48807 if (PyErr_Occurred()) SWIG_fail;
48808 }
48809 {
48810 resultobj = wxPyMake_wxObject(result, (bool)0);
48811 }
48812 return resultobj;
48813 fail:
48814 return NULL;
48815 }
48816
48817
48818 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48819 PyObject *obj;
48820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48821 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48822 return SWIG_Py_Void();
48823 }
48824
48825 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48826 return SWIG_Python_InitShadowInstance(args);
48827 }
48828
48829 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48830 PyObject *resultobj = 0;
48831 int arg1 = (int) 0 ;
48832 int arg2 = (int) 0 ;
48833 wxGBPosition *result = 0 ;
48834 int val1 ;
48835 int ecode1 = 0 ;
48836 int val2 ;
48837 int ecode2 = 0 ;
48838 PyObject * obj0 = 0 ;
48839 PyObject * obj1 = 0 ;
48840 char * kwnames[] = {
48841 (char *) "row",(char *) "col", NULL
48842 };
48843
48844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48845 if (obj0) {
48846 ecode1 = SWIG_AsVal_int(obj0, &val1);
48847 if (!SWIG_IsOK(ecode1)) {
48848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48849 }
48850 arg1 = static_cast< int >(val1);
48851 }
48852 if (obj1) {
48853 ecode2 = SWIG_AsVal_int(obj1, &val2);
48854 if (!SWIG_IsOK(ecode2)) {
48855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48856 }
48857 arg2 = static_cast< int >(val2);
48858 }
48859 {
48860 PyThreadState* __tstate = wxPyBeginAllowThreads();
48861 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48862 wxPyEndAllowThreads(__tstate);
48863 if (PyErr_Occurred()) SWIG_fail;
48864 }
48865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48866 return resultobj;
48867 fail:
48868 return NULL;
48869 }
48870
48871
48872 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48873 PyObject *resultobj = 0;
48874 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48875 void *argp1 = 0 ;
48876 int res1 = 0 ;
48877 PyObject *swig_obj[1] ;
48878
48879 if (!args) SWIG_fail;
48880 swig_obj[0] = args;
48881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48882 if (!SWIG_IsOK(res1)) {
48883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48884 }
48885 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48886 {
48887 PyThreadState* __tstate = wxPyBeginAllowThreads();
48888 delete arg1;
48889
48890 wxPyEndAllowThreads(__tstate);
48891 if (PyErr_Occurred()) SWIG_fail;
48892 }
48893 resultobj = SWIG_Py_Void();
48894 return resultobj;
48895 fail:
48896 return NULL;
48897 }
48898
48899
48900 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48901 PyObject *resultobj = 0;
48902 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48903 int result;
48904 void *argp1 = 0 ;
48905 int res1 = 0 ;
48906 PyObject *swig_obj[1] ;
48907
48908 if (!args) SWIG_fail;
48909 swig_obj[0] = args;
48910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48911 if (!SWIG_IsOK(res1)) {
48912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48913 }
48914 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48915 {
48916 PyThreadState* __tstate = wxPyBeginAllowThreads();
48917 result = (int)((wxGBPosition const *)arg1)->GetRow();
48918 wxPyEndAllowThreads(__tstate);
48919 if (PyErr_Occurred()) SWIG_fail;
48920 }
48921 resultobj = SWIG_From_int(static_cast< int >(result));
48922 return resultobj;
48923 fail:
48924 return NULL;
48925 }
48926
48927
48928 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48929 PyObject *resultobj = 0;
48930 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48931 int result;
48932 void *argp1 = 0 ;
48933 int res1 = 0 ;
48934 PyObject *swig_obj[1] ;
48935
48936 if (!args) SWIG_fail;
48937 swig_obj[0] = args;
48938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48939 if (!SWIG_IsOK(res1)) {
48940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48941 }
48942 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48943 {
48944 PyThreadState* __tstate = wxPyBeginAllowThreads();
48945 result = (int)((wxGBPosition const *)arg1)->GetCol();
48946 wxPyEndAllowThreads(__tstate);
48947 if (PyErr_Occurred()) SWIG_fail;
48948 }
48949 resultobj = SWIG_From_int(static_cast< int >(result));
48950 return resultobj;
48951 fail:
48952 return NULL;
48953 }
48954
48955
48956 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48957 PyObject *resultobj = 0;
48958 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48959 int arg2 ;
48960 void *argp1 = 0 ;
48961 int res1 = 0 ;
48962 int val2 ;
48963 int ecode2 = 0 ;
48964 PyObject * obj0 = 0 ;
48965 PyObject * obj1 = 0 ;
48966 char * kwnames[] = {
48967 (char *) "self",(char *) "row", NULL
48968 };
48969
48970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48972 if (!SWIG_IsOK(res1)) {
48973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48974 }
48975 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48976 ecode2 = SWIG_AsVal_int(obj1, &val2);
48977 if (!SWIG_IsOK(ecode2)) {
48978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48979 }
48980 arg2 = static_cast< int >(val2);
48981 {
48982 PyThreadState* __tstate = wxPyBeginAllowThreads();
48983 (arg1)->SetRow(arg2);
48984 wxPyEndAllowThreads(__tstate);
48985 if (PyErr_Occurred()) SWIG_fail;
48986 }
48987 resultobj = SWIG_Py_Void();
48988 return resultobj;
48989 fail:
48990 return NULL;
48991 }
48992
48993
48994 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48995 PyObject *resultobj = 0;
48996 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48997 int arg2 ;
48998 void *argp1 = 0 ;
48999 int res1 = 0 ;
49000 int val2 ;
49001 int ecode2 = 0 ;
49002 PyObject * obj0 = 0 ;
49003 PyObject * obj1 = 0 ;
49004 char * kwnames[] = {
49005 (char *) "self",(char *) "col", NULL
49006 };
49007
49008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49010 if (!SWIG_IsOK(res1)) {
49011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49012 }
49013 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49014 ecode2 = SWIG_AsVal_int(obj1, &val2);
49015 if (!SWIG_IsOK(ecode2)) {
49016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49017 }
49018 arg2 = static_cast< int >(val2);
49019 {
49020 PyThreadState* __tstate = wxPyBeginAllowThreads();
49021 (arg1)->SetCol(arg2);
49022 wxPyEndAllowThreads(__tstate);
49023 if (PyErr_Occurred()) SWIG_fail;
49024 }
49025 resultobj = SWIG_Py_Void();
49026 return resultobj;
49027 fail:
49028 return NULL;
49029 }
49030
49031
49032 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49033 PyObject *resultobj = 0;
49034 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49035 PyObject *arg2 = (PyObject *) 0 ;
49036 bool result;
49037 void *argp1 = 0 ;
49038 int res1 = 0 ;
49039 PyObject * obj0 = 0 ;
49040 PyObject * obj1 = 0 ;
49041 char * kwnames[] = {
49042 (char *) "self",(char *) "other", NULL
49043 };
49044
49045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49047 if (!SWIG_IsOK(res1)) {
49048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49049 }
49050 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49051 arg2 = obj1;
49052 {
49053 result = (bool)wxGBPosition___eq__(arg1,arg2);
49054 if (PyErr_Occurred()) SWIG_fail;
49055 }
49056 {
49057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49058 }
49059 return resultobj;
49060 fail:
49061 return NULL;
49062 }
49063
49064
49065 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49066 PyObject *resultobj = 0;
49067 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49068 PyObject *arg2 = (PyObject *) 0 ;
49069 bool result;
49070 void *argp1 = 0 ;
49071 int res1 = 0 ;
49072 PyObject * obj0 = 0 ;
49073 PyObject * obj1 = 0 ;
49074 char * kwnames[] = {
49075 (char *) "self",(char *) "other", NULL
49076 };
49077
49078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49080 if (!SWIG_IsOK(res1)) {
49081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49082 }
49083 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49084 arg2 = obj1;
49085 {
49086 result = (bool)wxGBPosition___ne__(arg1,arg2);
49087 if (PyErr_Occurred()) SWIG_fail;
49088 }
49089 {
49090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49091 }
49092 return resultobj;
49093 fail:
49094 return NULL;
49095 }
49096
49097
49098 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49099 PyObject *resultobj = 0;
49100 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49101 int arg2 = (int) 0 ;
49102 int arg3 = (int) 0 ;
49103 void *argp1 = 0 ;
49104 int res1 = 0 ;
49105 int val2 ;
49106 int ecode2 = 0 ;
49107 int val3 ;
49108 int ecode3 = 0 ;
49109 PyObject * obj0 = 0 ;
49110 PyObject * obj1 = 0 ;
49111 PyObject * obj2 = 0 ;
49112 char * kwnames[] = {
49113 (char *) "self",(char *) "row",(char *) "col", NULL
49114 };
49115
49116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49118 if (!SWIG_IsOK(res1)) {
49119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49120 }
49121 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49122 if (obj1) {
49123 ecode2 = SWIG_AsVal_int(obj1, &val2);
49124 if (!SWIG_IsOK(ecode2)) {
49125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49126 }
49127 arg2 = static_cast< int >(val2);
49128 }
49129 if (obj2) {
49130 ecode3 = SWIG_AsVal_int(obj2, &val3);
49131 if (!SWIG_IsOK(ecode3)) {
49132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49133 }
49134 arg3 = static_cast< int >(val3);
49135 }
49136 {
49137 PyThreadState* __tstate = wxPyBeginAllowThreads();
49138 wxGBPosition_Set(arg1,arg2,arg3);
49139 wxPyEndAllowThreads(__tstate);
49140 if (PyErr_Occurred()) SWIG_fail;
49141 }
49142 resultobj = SWIG_Py_Void();
49143 return resultobj;
49144 fail:
49145 return NULL;
49146 }
49147
49148
49149 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49150 PyObject *resultobj = 0;
49151 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49152 PyObject *result = 0 ;
49153 void *argp1 = 0 ;
49154 int res1 = 0 ;
49155 PyObject *swig_obj[1] ;
49156
49157 if (!args) SWIG_fail;
49158 swig_obj[0] = args;
49159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49160 if (!SWIG_IsOK(res1)) {
49161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49162 }
49163 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49164 {
49165 PyThreadState* __tstate = wxPyBeginAllowThreads();
49166 result = (PyObject *)wxGBPosition_Get(arg1);
49167 wxPyEndAllowThreads(__tstate);
49168 if (PyErr_Occurred()) SWIG_fail;
49169 }
49170 resultobj = result;
49171 return resultobj;
49172 fail:
49173 return NULL;
49174 }
49175
49176
49177 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49178 PyObject *obj;
49179 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49180 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49181 return SWIG_Py_Void();
49182 }
49183
49184 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49185 return SWIG_Python_InitShadowInstance(args);
49186 }
49187
49188 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49189 PyObject *resultobj = 0;
49190 int arg1 = (int) 1 ;
49191 int arg2 = (int) 1 ;
49192 wxGBSpan *result = 0 ;
49193 int val1 ;
49194 int ecode1 = 0 ;
49195 int val2 ;
49196 int ecode2 = 0 ;
49197 PyObject * obj0 = 0 ;
49198 PyObject * obj1 = 0 ;
49199 char * kwnames[] = {
49200 (char *) "rowspan",(char *) "colspan", NULL
49201 };
49202
49203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49204 if (obj0) {
49205 ecode1 = SWIG_AsVal_int(obj0, &val1);
49206 if (!SWIG_IsOK(ecode1)) {
49207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49208 }
49209 arg1 = static_cast< int >(val1);
49210 }
49211 if (obj1) {
49212 ecode2 = SWIG_AsVal_int(obj1, &val2);
49213 if (!SWIG_IsOK(ecode2)) {
49214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49215 }
49216 arg2 = static_cast< int >(val2);
49217 }
49218 {
49219 PyThreadState* __tstate = wxPyBeginAllowThreads();
49220 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49221 wxPyEndAllowThreads(__tstate);
49222 if (PyErr_Occurred()) SWIG_fail;
49223 }
49224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49225 return resultobj;
49226 fail:
49227 return NULL;
49228 }
49229
49230
49231 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49232 PyObject *resultobj = 0;
49233 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49234 void *argp1 = 0 ;
49235 int res1 = 0 ;
49236 PyObject *swig_obj[1] ;
49237
49238 if (!args) SWIG_fail;
49239 swig_obj[0] = args;
49240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49241 if (!SWIG_IsOK(res1)) {
49242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49243 }
49244 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49245 {
49246 PyThreadState* __tstate = wxPyBeginAllowThreads();
49247 delete arg1;
49248
49249 wxPyEndAllowThreads(__tstate);
49250 if (PyErr_Occurred()) SWIG_fail;
49251 }
49252 resultobj = SWIG_Py_Void();
49253 return resultobj;
49254 fail:
49255 return NULL;
49256 }
49257
49258
49259 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49260 PyObject *resultobj = 0;
49261 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49262 int result;
49263 void *argp1 = 0 ;
49264 int res1 = 0 ;
49265 PyObject *swig_obj[1] ;
49266
49267 if (!args) SWIG_fail;
49268 swig_obj[0] = args;
49269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49270 if (!SWIG_IsOK(res1)) {
49271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49272 }
49273 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49274 {
49275 PyThreadState* __tstate = wxPyBeginAllowThreads();
49276 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49277 wxPyEndAllowThreads(__tstate);
49278 if (PyErr_Occurred()) SWIG_fail;
49279 }
49280 resultobj = SWIG_From_int(static_cast< int >(result));
49281 return resultobj;
49282 fail:
49283 return NULL;
49284 }
49285
49286
49287 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49288 PyObject *resultobj = 0;
49289 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49290 int result;
49291 void *argp1 = 0 ;
49292 int res1 = 0 ;
49293 PyObject *swig_obj[1] ;
49294
49295 if (!args) SWIG_fail;
49296 swig_obj[0] = args;
49297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49298 if (!SWIG_IsOK(res1)) {
49299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49300 }
49301 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49302 {
49303 PyThreadState* __tstate = wxPyBeginAllowThreads();
49304 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49305 wxPyEndAllowThreads(__tstate);
49306 if (PyErr_Occurred()) SWIG_fail;
49307 }
49308 resultobj = SWIG_From_int(static_cast< int >(result));
49309 return resultobj;
49310 fail:
49311 return NULL;
49312 }
49313
49314
49315 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49316 PyObject *resultobj = 0;
49317 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49318 int arg2 ;
49319 void *argp1 = 0 ;
49320 int res1 = 0 ;
49321 int val2 ;
49322 int ecode2 = 0 ;
49323 PyObject * obj0 = 0 ;
49324 PyObject * obj1 = 0 ;
49325 char * kwnames[] = {
49326 (char *) "self",(char *) "rowspan", NULL
49327 };
49328
49329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49331 if (!SWIG_IsOK(res1)) {
49332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49333 }
49334 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49335 ecode2 = SWIG_AsVal_int(obj1, &val2);
49336 if (!SWIG_IsOK(ecode2)) {
49337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49338 }
49339 arg2 = static_cast< int >(val2);
49340 {
49341 PyThreadState* __tstate = wxPyBeginAllowThreads();
49342 (arg1)->SetRowspan(arg2);
49343 wxPyEndAllowThreads(__tstate);
49344 if (PyErr_Occurred()) SWIG_fail;
49345 }
49346 resultobj = SWIG_Py_Void();
49347 return resultobj;
49348 fail:
49349 return NULL;
49350 }
49351
49352
49353 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49354 PyObject *resultobj = 0;
49355 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49356 int arg2 ;
49357 void *argp1 = 0 ;
49358 int res1 = 0 ;
49359 int val2 ;
49360 int ecode2 = 0 ;
49361 PyObject * obj0 = 0 ;
49362 PyObject * obj1 = 0 ;
49363 char * kwnames[] = {
49364 (char *) "self",(char *) "colspan", NULL
49365 };
49366
49367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49369 if (!SWIG_IsOK(res1)) {
49370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49371 }
49372 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49373 ecode2 = SWIG_AsVal_int(obj1, &val2);
49374 if (!SWIG_IsOK(ecode2)) {
49375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49376 }
49377 arg2 = static_cast< int >(val2);
49378 {
49379 PyThreadState* __tstate = wxPyBeginAllowThreads();
49380 (arg1)->SetColspan(arg2);
49381 wxPyEndAllowThreads(__tstate);
49382 if (PyErr_Occurred()) SWIG_fail;
49383 }
49384 resultobj = SWIG_Py_Void();
49385 return resultobj;
49386 fail:
49387 return NULL;
49388 }
49389
49390
49391 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49392 PyObject *resultobj = 0;
49393 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49394 PyObject *arg2 = (PyObject *) 0 ;
49395 bool result;
49396 void *argp1 = 0 ;
49397 int res1 = 0 ;
49398 PyObject * obj0 = 0 ;
49399 PyObject * obj1 = 0 ;
49400 char * kwnames[] = {
49401 (char *) "self",(char *) "other", NULL
49402 };
49403
49404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49406 if (!SWIG_IsOK(res1)) {
49407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49408 }
49409 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49410 arg2 = obj1;
49411 {
49412 result = (bool)wxGBSpan___eq__(arg1,arg2);
49413 if (PyErr_Occurred()) SWIG_fail;
49414 }
49415 {
49416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49417 }
49418 return resultobj;
49419 fail:
49420 return NULL;
49421 }
49422
49423
49424 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49425 PyObject *resultobj = 0;
49426 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49427 PyObject *arg2 = (PyObject *) 0 ;
49428 bool result;
49429 void *argp1 = 0 ;
49430 int res1 = 0 ;
49431 PyObject * obj0 = 0 ;
49432 PyObject * obj1 = 0 ;
49433 char * kwnames[] = {
49434 (char *) "self",(char *) "other", NULL
49435 };
49436
49437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49439 if (!SWIG_IsOK(res1)) {
49440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49441 }
49442 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49443 arg2 = obj1;
49444 {
49445 result = (bool)wxGBSpan___ne__(arg1,arg2);
49446 if (PyErr_Occurred()) SWIG_fail;
49447 }
49448 {
49449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49450 }
49451 return resultobj;
49452 fail:
49453 return NULL;
49454 }
49455
49456
49457 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49458 PyObject *resultobj = 0;
49459 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49460 int arg2 = (int) 1 ;
49461 int arg3 = (int) 1 ;
49462 void *argp1 = 0 ;
49463 int res1 = 0 ;
49464 int val2 ;
49465 int ecode2 = 0 ;
49466 int val3 ;
49467 int ecode3 = 0 ;
49468 PyObject * obj0 = 0 ;
49469 PyObject * obj1 = 0 ;
49470 PyObject * obj2 = 0 ;
49471 char * kwnames[] = {
49472 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49473 };
49474
49475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49477 if (!SWIG_IsOK(res1)) {
49478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49479 }
49480 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49481 if (obj1) {
49482 ecode2 = SWIG_AsVal_int(obj1, &val2);
49483 if (!SWIG_IsOK(ecode2)) {
49484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49485 }
49486 arg2 = static_cast< int >(val2);
49487 }
49488 if (obj2) {
49489 ecode3 = SWIG_AsVal_int(obj2, &val3);
49490 if (!SWIG_IsOK(ecode3)) {
49491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49492 }
49493 arg3 = static_cast< int >(val3);
49494 }
49495 {
49496 PyThreadState* __tstate = wxPyBeginAllowThreads();
49497 wxGBSpan_Set(arg1,arg2,arg3);
49498 wxPyEndAllowThreads(__tstate);
49499 if (PyErr_Occurred()) SWIG_fail;
49500 }
49501 resultobj = SWIG_Py_Void();
49502 return resultobj;
49503 fail:
49504 return NULL;
49505 }
49506
49507
49508 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49509 PyObject *resultobj = 0;
49510 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49511 PyObject *result = 0 ;
49512 void *argp1 = 0 ;
49513 int res1 = 0 ;
49514 PyObject *swig_obj[1] ;
49515
49516 if (!args) SWIG_fail;
49517 swig_obj[0] = args;
49518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49519 if (!SWIG_IsOK(res1)) {
49520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49521 }
49522 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49523 {
49524 PyThreadState* __tstate = wxPyBeginAllowThreads();
49525 result = (PyObject *)wxGBSpan_Get(arg1);
49526 wxPyEndAllowThreads(__tstate);
49527 if (PyErr_Occurred()) SWIG_fail;
49528 }
49529 resultobj = result;
49530 return resultobj;
49531 fail:
49532 return NULL;
49533 }
49534
49535
49536 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49537 PyObject *obj;
49538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49539 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49540 return SWIG_Py_Void();
49541 }
49542
49543 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49544 return SWIG_Python_InitShadowInstance(args);
49545 }
49546
49547 SWIGINTERN int DefaultSpan_set(PyObject *) {
49548 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49549 return 1;
49550 }
49551
49552
49553 SWIGINTERN PyObject *DefaultSpan_get(void) {
49554 PyObject *pyobj = 0;
49555
49556 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49557 return pyobj;
49558 }
49559
49560
49561 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49562 PyObject *resultobj = 0;
49563 wxGBSizerItem *result = 0 ;
49564
49565 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49566 {
49567 PyThreadState* __tstate = wxPyBeginAllowThreads();
49568 result = (wxGBSizerItem *)new wxGBSizerItem();
49569 wxPyEndAllowThreads(__tstate);
49570 if (PyErr_Occurred()) SWIG_fail;
49571 }
49572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49573 return resultobj;
49574 fail:
49575 return NULL;
49576 }
49577
49578
49579 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49580 PyObject *resultobj = 0;
49581 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49582 void *argp1 = 0 ;
49583 int res1 = 0 ;
49584 PyObject *swig_obj[1] ;
49585
49586 if (!args) SWIG_fail;
49587 swig_obj[0] = args;
49588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49589 if (!SWIG_IsOK(res1)) {
49590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49591 }
49592 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49593 {
49594 PyThreadState* __tstate = wxPyBeginAllowThreads();
49595 delete arg1;
49596
49597 wxPyEndAllowThreads(__tstate);
49598 if (PyErr_Occurred()) SWIG_fail;
49599 }
49600 resultobj = SWIG_Py_Void();
49601 return resultobj;
49602 fail:
49603 return NULL;
49604 }
49605
49606
49607 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49608 PyObject *resultobj = 0;
49609 wxWindow *arg1 = (wxWindow *) 0 ;
49610 wxGBPosition *arg2 = 0 ;
49611 wxGBSpan *arg3 = 0 ;
49612 int arg4 ;
49613 int arg5 ;
49614 PyObject *arg6 = (PyObject *) NULL ;
49615 wxGBSizerItem *result = 0 ;
49616 void *argp1 = 0 ;
49617 int res1 = 0 ;
49618 wxGBPosition temp2 ;
49619 wxGBSpan temp3 ;
49620 int val4 ;
49621 int ecode4 = 0 ;
49622 int val5 ;
49623 int ecode5 = 0 ;
49624 PyObject * obj0 = 0 ;
49625 PyObject * obj1 = 0 ;
49626 PyObject * obj2 = 0 ;
49627 PyObject * obj3 = 0 ;
49628 PyObject * obj4 = 0 ;
49629 PyObject * obj5 = 0 ;
49630 char * kwnames[] = {
49631 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49632 };
49633
49634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49636 if (!SWIG_IsOK(res1)) {
49637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49638 }
49639 arg1 = reinterpret_cast< wxWindow * >(argp1);
49640 {
49641 arg2 = &temp2;
49642 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49643 }
49644 {
49645 arg3 = &temp3;
49646 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49647 }
49648 ecode4 = SWIG_AsVal_int(obj3, &val4);
49649 if (!SWIG_IsOK(ecode4)) {
49650 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49651 }
49652 arg4 = static_cast< int >(val4);
49653 ecode5 = SWIG_AsVal_int(obj4, &val5);
49654 if (!SWIG_IsOK(ecode5)) {
49655 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49656 }
49657 arg5 = static_cast< int >(val5);
49658 if (obj5) {
49659 arg6 = obj5;
49660 }
49661 {
49662 PyThreadState* __tstate = wxPyBeginAllowThreads();
49663 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49664 wxPyEndAllowThreads(__tstate);
49665 if (PyErr_Occurred()) SWIG_fail;
49666 }
49667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49668 return resultobj;
49669 fail:
49670 return NULL;
49671 }
49672
49673
49674 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49675 PyObject *resultobj = 0;
49676 wxSizer *arg1 = (wxSizer *) 0 ;
49677 wxGBPosition *arg2 = 0 ;
49678 wxGBSpan *arg3 = 0 ;
49679 int arg4 ;
49680 int arg5 ;
49681 PyObject *arg6 = (PyObject *) NULL ;
49682 wxGBSizerItem *result = 0 ;
49683 int res1 = 0 ;
49684 wxGBPosition temp2 ;
49685 wxGBSpan temp3 ;
49686 int val4 ;
49687 int ecode4 = 0 ;
49688 int val5 ;
49689 int ecode5 = 0 ;
49690 PyObject * obj0 = 0 ;
49691 PyObject * obj1 = 0 ;
49692 PyObject * obj2 = 0 ;
49693 PyObject * obj3 = 0 ;
49694 PyObject * obj4 = 0 ;
49695 PyObject * obj5 = 0 ;
49696 char * kwnames[] = {
49697 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49698 };
49699
49700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49701 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49702 if (!SWIG_IsOK(res1)) {
49703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49704 }
49705 {
49706 arg2 = &temp2;
49707 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49708 }
49709 {
49710 arg3 = &temp3;
49711 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49712 }
49713 ecode4 = SWIG_AsVal_int(obj3, &val4);
49714 if (!SWIG_IsOK(ecode4)) {
49715 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49716 }
49717 arg4 = static_cast< int >(val4);
49718 ecode5 = SWIG_AsVal_int(obj4, &val5);
49719 if (!SWIG_IsOK(ecode5)) {
49720 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49721 }
49722 arg5 = static_cast< int >(val5);
49723 if (obj5) {
49724 arg6 = obj5;
49725 }
49726 {
49727 PyThreadState* __tstate = wxPyBeginAllowThreads();
49728 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49729 wxPyEndAllowThreads(__tstate);
49730 if (PyErr_Occurred()) SWIG_fail;
49731 }
49732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49733 return resultobj;
49734 fail:
49735 return NULL;
49736 }
49737
49738
49739 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49740 PyObject *resultobj = 0;
49741 int arg1 ;
49742 int arg2 ;
49743 wxGBPosition *arg3 = 0 ;
49744 wxGBSpan *arg4 = 0 ;
49745 int arg5 ;
49746 int arg6 ;
49747 PyObject *arg7 = (PyObject *) NULL ;
49748 wxGBSizerItem *result = 0 ;
49749 int val1 ;
49750 int ecode1 = 0 ;
49751 int val2 ;
49752 int ecode2 = 0 ;
49753 wxGBPosition temp3 ;
49754 wxGBSpan temp4 ;
49755 int val5 ;
49756 int ecode5 = 0 ;
49757 int val6 ;
49758 int ecode6 = 0 ;
49759 PyObject * obj0 = 0 ;
49760 PyObject * obj1 = 0 ;
49761 PyObject * obj2 = 0 ;
49762 PyObject * obj3 = 0 ;
49763 PyObject * obj4 = 0 ;
49764 PyObject * obj5 = 0 ;
49765 PyObject * obj6 = 0 ;
49766 char * kwnames[] = {
49767 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49768 };
49769
49770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49771 ecode1 = SWIG_AsVal_int(obj0, &val1);
49772 if (!SWIG_IsOK(ecode1)) {
49773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49774 }
49775 arg1 = static_cast< int >(val1);
49776 ecode2 = SWIG_AsVal_int(obj1, &val2);
49777 if (!SWIG_IsOK(ecode2)) {
49778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49779 }
49780 arg2 = static_cast< int >(val2);
49781 {
49782 arg3 = &temp3;
49783 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49784 }
49785 {
49786 arg4 = &temp4;
49787 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49788 }
49789 ecode5 = SWIG_AsVal_int(obj4, &val5);
49790 if (!SWIG_IsOK(ecode5)) {
49791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49792 }
49793 arg5 = static_cast< int >(val5);
49794 ecode6 = SWIG_AsVal_int(obj5, &val6);
49795 if (!SWIG_IsOK(ecode6)) {
49796 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49797 }
49798 arg6 = static_cast< int >(val6);
49799 if (obj6) {
49800 arg7 = obj6;
49801 }
49802 {
49803 PyThreadState* __tstate = wxPyBeginAllowThreads();
49804 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49805 wxPyEndAllowThreads(__tstate);
49806 if (PyErr_Occurred()) SWIG_fail;
49807 }
49808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49809 return resultobj;
49810 fail:
49811 return NULL;
49812 }
49813
49814
49815 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49816 PyObject *resultobj = 0;
49817 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49818 wxGBPosition result;
49819 void *argp1 = 0 ;
49820 int res1 = 0 ;
49821 PyObject *swig_obj[1] ;
49822
49823 if (!args) SWIG_fail;
49824 swig_obj[0] = args;
49825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49826 if (!SWIG_IsOK(res1)) {
49827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49828 }
49829 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49830 {
49831 PyThreadState* __tstate = wxPyBeginAllowThreads();
49832 result = ((wxGBSizerItem const *)arg1)->GetPos();
49833 wxPyEndAllowThreads(__tstate);
49834 if (PyErr_Occurred()) SWIG_fail;
49835 }
49836 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49837 return resultobj;
49838 fail:
49839 return NULL;
49840 }
49841
49842
49843 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49844 PyObject *resultobj = 0;
49845 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49846 wxGBSpan result;
49847 void *argp1 = 0 ;
49848 int res1 = 0 ;
49849 PyObject *swig_obj[1] ;
49850
49851 if (!args) SWIG_fail;
49852 swig_obj[0] = args;
49853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49854 if (!SWIG_IsOK(res1)) {
49855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49856 }
49857 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49858 {
49859 PyThreadState* __tstate = wxPyBeginAllowThreads();
49860 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49861 wxPyEndAllowThreads(__tstate);
49862 if (PyErr_Occurred()) SWIG_fail;
49863 }
49864 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49865 return resultobj;
49866 fail:
49867 return NULL;
49868 }
49869
49870
49871 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49872 PyObject *resultobj = 0;
49873 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49874 wxGBPosition *arg2 = 0 ;
49875 bool result;
49876 void *argp1 = 0 ;
49877 int res1 = 0 ;
49878 wxGBPosition temp2 ;
49879 PyObject * obj0 = 0 ;
49880 PyObject * obj1 = 0 ;
49881 char * kwnames[] = {
49882 (char *) "self",(char *) "pos", NULL
49883 };
49884
49885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49887 if (!SWIG_IsOK(res1)) {
49888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49889 }
49890 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49891 {
49892 arg2 = &temp2;
49893 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49894 }
49895 {
49896 PyThreadState* __tstate = wxPyBeginAllowThreads();
49897 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49898 wxPyEndAllowThreads(__tstate);
49899 if (PyErr_Occurred()) SWIG_fail;
49900 }
49901 {
49902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49903 }
49904 return resultobj;
49905 fail:
49906 return NULL;
49907 }
49908
49909
49910 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49911 PyObject *resultobj = 0;
49912 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49913 wxGBSpan *arg2 = 0 ;
49914 bool result;
49915 void *argp1 = 0 ;
49916 int res1 = 0 ;
49917 wxGBSpan temp2 ;
49918 PyObject * obj0 = 0 ;
49919 PyObject * obj1 = 0 ;
49920 char * kwnames[] = {
49921 (char *) "self",(char *) "span", NULL
49922 };
49923
49924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49926 if (!SWIG_IsOK(res1)) {
49927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49928 }
49929 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49930 {
49931 arg2 = &temp2;
49932 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49933 }
49934 {
49935 PyThreadState* __tstate = wxPyBeginAllowThreads();
49936 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49937 wxPyEndAllowThreads(__tstate);
49938 if (PyErr_Occurred()) SWIG_fail;
49939 }
49940 {
49941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49942 }
49943 return resultobj;
49944 fail:
49945 return NULL;
49946 }
49947
49948
49949 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49950 PyObject *resultobj = 0;
49951 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49952 wxGBSizerItem *arg2 = 0 ;
49953 bool result;
49954 void *argp1 = 0 ;
49955 int res1 = 0 ;
49956 void *argp2 = 0 ;
49957 int res2 = 0 ;
49958 PyObject * obj0 = 0 ;
49959 PyObject * obj1 = 0 ;
49960 char * kwnames[] = {
49961 (char *) "self",(char *) "other", NULL
49962 };
49963
49964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49966 if (!SWIG_IsOK(res1)) {
49967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49968 }
49969 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49970 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49971 if (!SWIG_IsOK(res2)) {
49972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49973 }
49974 if (!argp2) {
49975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49976 }
49977 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49978 {
49979 PyThreadState* __tstate = wxPyBeginAllowThreads();
49980 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49981 wxPyEndAllowThreads(__tstate);
49982 if (PyErr_Occurred()) SWIG_fail;
49983 }
49984 {
49985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49986 }
49987 return resultobj;
49988 fail:
49989 return NULL;
49990 }
49991
49992
49993 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49994 PyObject *resultobj = 0;
49995 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49996 wxGBPosition *arg2 = 0 ;
49997 wxGBSpan *arg3 = 0 ;
49998 bool result;
49999 void *argp1 = 0 ;
50000 int res1 = 0 ;
50001 wxGBPosition temp2 ;
50002 wxGBSpan temp3 ;
50003 PyObject * obj0 = 0 ;
50004 PyObject * obj1 = 0 ;
50005 PyObject * obj2 = 0 ;
50006 char * kwnames[] = {
50007 (char *) "self",(char *) "pos",(char *) "span", NULL
50008 };
50009
50010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50012 if (!SWIG_IsOK(res1)) {
50013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50014 }
50015 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50016 {
50017 arg2 = &temp2;
50018 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50019 }
50020 {
50021 arg3 = &temp3;
50022 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50023 }
50024 {
50025 PyThreadState* __tstate = wxPyBeginAllowThreads();
50026 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50027 wxPyEndAllowThreads(__tstate);
50028 if (PyErr_Occurred()) SWIG_fail;
50029 }
50030 {
50031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50032 }
50033 return resultobj;
50034 fail:
50035 return NULL;
50036 }
50037
50038
50039 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50040 PyObject *resultobj = 0;
50041 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50042 wxGBPosition result;
50043 void *argp1 = 0 ;
50044 int res1 = 0 ;
50045 PyObject *swig_obj[1] ;
50046
50047 if (!args) SWIG_fail;
50048 swig_obj[0] = args;
50049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50050 if (!SWIG_IsOK(res1)) {
50051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50052 }
50053 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50054 {
50055 PyThreadState* __tstate = wxPyBeginAllowThreads();
50056 result = wxGBSizerItem_GetEndPos(arg1);
50057 wxPyEndAllowThreads(__tstate);
50058 if (PyErr_Occurred()) SWIG_fail;
50059 }
50060 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50061 return resultobj;
50062 fail:
50063 return NULL;
50064 }
50065
50066
50067 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50068 PyObject *resultobj = 0;
50069 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50070 wxGridBagSizer *result = 0 ;
50071 void *argp1 = 0 ;
50072 int res1 = 0 ;
50073 PyObject *swig_obj[1] ;
50074
50075 if (!args) SWIG_fail;
50076 swig_obj[0] = args;
50077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50078 if (!SWIG_IsOK(res1)) {
50079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50080 }
50081 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50082 {
50083 PyThreadState* __tstate = wxPyBeginAllowThreads();
50084 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50085 wxPyEndAllowThreads(__tstate);
50086 if (PyErr_Occurred()) SWIG_fail;
50087 }
50088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50089 return resultobj;
50090 fail:
50091 return NULL;
50092 }
50093
50094
50095 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50096 PyObject *resultobj = 0;
50097 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50098 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50099 void *argp1 = 0 ;
50100 int res1 = 0 ;
50101 void *argp2 = 0 ;
50102 int res2 = 0 ;
50103 PyObject * obj0 = 0 ;
50104 PyObject * obj1 = 0 ;
50105 char * kwnames[] = {
50106 (char *) "self",(char *) "sizer", NULL
50107 };
50108
50109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50111 if (!SWIG_IsOK(res1)) {
50112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50113 }
50114 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50115 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50116 if (!SWIG_IsOK(res2)) {
50117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50118 }
50119 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50120 {
50121 PyThreadState* __tstate = wxPyBeginAllowThreads();
50122 (arg1)->SetGBSizer(arg2);
50123 wxPyEndAllowThreads(__tstate);
50124 if (PyErr_Occurred()) SWIG_fail;
50125 }
50126 resultobj = SWIG_Py_Void();
50127 return resultobj;
50128 fail:
50129 return NULL;
50130 }
50131
50132
50133 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50134 PyObject *obj;
50135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50136 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50137 return SWIG_Py_Void();
50138 }
50139
50140 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50141 return SWIG_Python_InitShadowInstance(args);
50142 }
50143
50144 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50145 PyObject *resultobj = 0;
50146 int arg1 = (int) 0 ;
50147 int arg2 = (int) 0 ;
50148 wxGridBagSizer *result = 0 ;
50149 int val1 ;
50150 int ecode1 = 0 ;
50151 int val2 ;
50152 int ecode2 = 0 ;
50153 PyObject * obj0 = 0 ;
50154 PyObject * obj1 = 0 ;
50155 char * kwnames[] = {
50156 (char *) "vgap",(char *) "hgap", NULL
50157 };
50158
50159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50160 if (obj0) {
50161 ecode1 = SWIG_AsVal_int(obj0, &val1);
50162 if (!SWIG_IsOK(ecode1)) {
50163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50164 }
50165 arg1 = static_cast< int >(val1);
50166 }
50167 if (obj1) {
50168 ecode2 = SWIG_AsVal_int(obj1, &val2);
50169 if (!SWIG_IsOK(ecode2)) {
50170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50171 }
50172 arg2 = static_cast< int >(val2);
50173 }
50174 {
50175 PyThreadState* __tstate = wxPyBeginAllowThreads();
50176 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50177 wxPyEndAllowThreads(__tstate);
50178 if (PyErr_Occurred()) SWIG_fail;
50179 }
50180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50181 return resultobj;
50182 fail:
50183 return NULL;
50184 }
50185
50186
50187 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50188 PyObject *resultobj = 0;
50189 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50190 PyObject *arg2 = (PyObject *) 0 ;
50191 wxGBPosition *arg3 = 0 ;
50192 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50193 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50194 int arg5 = (int) 0 ;
50195 int arg6 = (int) 0 ;
50196 PyObject *arg7 = (PyObject *) NULL ;
50197 wxGBSizerItem *result = 0 ;
50198 void *argp1 = 0 ;
50199 int res1 = 0 ;
50200 wxGBPosition temp3 ;
50201 wxGBSpan temp4 ;
50202 int val5 ;
50203 int ecode5 = 0 ;
50204 int val6 ;
50205 int ecode6 = 0 ;
50206 PyObject * obj0 = 0 ;
50207 PyObject * obj1 = 0 ;
50208 PyObject * obj2 = 0 ;
50209 PyObject * obj3 = 0 ;
50210 PyObject * obj4 = 0 ;
50211 PyObject * obj5 = 0 ;
50212 PyObject * obj6 = 0 ;
50213 char * kwnames[] = {
50214 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50215 };
50216
50217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50219 if (!SWIG_IsOK(res1)) {
50220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50221 }
50222 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50223 arg2 = obj1;
50224 {
50225 arg3 = &temp3;
50226 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50227 }
50228 if (obj3) {
50229 {
50230 arg4 = &temp4;
50231 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50232 }
50233 }
50234 if (obj4) {
50235 ecode5 = SWIG_AsVal_int(obj4, &val5);
50236 if (!SWIG_IsOK(ecode5)) {
50237 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50238 }
50239 arg5 = static_cast< int >(val5);
50240 }
50241 if (obj5) {
50242 ecode6 = SWIG_AsVal_int(obj5, &val6);
50243 if (!SWIG_IsOK(ecode6)) {
50244 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50245 }
50246 arg6 = static_cast< int >(val6);
50247 }
50248 if (obj6) {
50249 arg7 = obj6;
50250 }
50251 {
50252 PyThreadState* __tstate = wxPyBeginAllowThreads();
50253 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50254 wxPyEndAllowThreads(__tstate);
50255 if (PyErr_Occurred()) SWIG_fail;
50256 }
50257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50258 return resultobj;
50259 fail:
50260 return NULL;
50261 }
50262
50263
50264 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50265 PyObject *resultobj = 0;
50266 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50267 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50268 wxGBSizerItem *result = 0 ;
50269 void *argp1 = 0 ;
50270 int res1 = 0 ;
50271 int res2 = 0 ;
50272 PyObject * obj0 = 0 ;
50273 PyObject * obj1 = 0 ;
50274 char * kwnames[] = {
50275 (char *) "self",(char *) "item", NULL
50276 };
50277
50278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50280 if (!SWIG_IsOK(res1)) {
50281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50282 }
50283 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50284 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50285 if (!SWIG_IsOK(res2)) {
50286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50287 }
50288 {
50289 PyThreadState* __tstate = wxPyBeginAllowThreads();
50290 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50291 wxPyEndAllowThreads(__tstate);
50292 if (PyErr_Occurred()) SWIG_fail;
50293 }
50294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50295 return resultobj;
50296 fail:
50297 return NULL;
50298 }
50299
50300
50301 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50302 PyObject *resultobj = 0;
50303 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50304 int arg2 ;
50305 int arg3 ;
50306 wxSize result;
50307 void *argp1 = 0 ;
50308 int res1 = 0 ;
50309 int val2 ;
50310 int ecode2 = 0 ;
50311 int val3 ;
50312 int ecode3 = 0 ;
50313 PyObject * obj0 = 0 ;
50314 PyObject * obj1 = 0 ;
50315 PyObject * obj2 = 0 ;
50316 char * kwnames[] = {
50317 (char *) "self",(char *) "row",(char *) "col", NULL
50318 };
50319
50320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50322 if (!SWIG_IsOK(res1)) {
50323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50324 }
50325 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50326 ecode2 = SWIG_AsVal_int(obj1, &val2);
50327 if (!SWIG_IsOK(ecode2)) {
50328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50329 }
50330 arg2 = static_cast< int >(val2);
50331 ecode3 = SWIG_AsVal_int(obj2, &val3);
50332 if (!SWIG_IsOK(ecode3)) {
50333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50334 }
50335 arg3 = static_cast< int >(val3);
50336 {
50337 PyThreadState* __tstate = wxPyBeginAllowThreads();
50338 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50339 wxPyEndAllowThreads(__tstate);
50340 if (PyErr_Occurred()) SWIG_fail;
50341 }
50342 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50343 return resultobj;
50344 fail:
50345 return NULL;
50346 }
50347
50348
50349 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50350 PyObject *resultobj = 0;
50351 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50352 wxSize result;
50353 void *argp1 = 0 ;
50354 int res1 = 0 ;
50355 PyObject *swig_obj[1] ;
50356
50357 if (!args) SWIG_fail;
50358 swig_obj[0] = args;
50359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50360 if (!SWIG_IsOK(res1)) {
50361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50362 }
50363 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50364 {
50365 PyThreadState* __tstate = wxPyBeginAllowThreads();
50366 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50367 wxPyEndAllowThreads(__tstate);
50368 if (PyErr_Occurred()) SWIG_fail;
50369 }
50370 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50371 return resultobj;
50372 fail:
50373 return NULL;
50374 }
50375
50376
50377 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50378 PyObject *resultobj = 0;
50379 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50380 wxSize *arg2 = 0 ;
50381 void *argp1 = 0 ;
50382 int res1 = 0 ;
50383 wxSize temp2 ;
50384 PyObject * obj0 = 0 ;
50385 PyObject * obj1 = 0 ;
50386 char * kwnames[] = {
50387 (char *) "self",(char *) "sz", NULL
50388 };
50389
50390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50392 if (!SWIG_IsOK(res1)) {
50393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50394 }
50395 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50396 {
50397 arg2 = &temp2;
50398 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50399 }
50400 {
50401 PyThreadState* __tstate = wxPyBeginAllowThreads();
50402 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50403 wxPyEndAllowThreads(__tstate);
50404 if (PyErr_Occurred()) SWIG_fail;
50405 }
50406 resultobj = SWIG_Py_Void();
50407 return resultobj;
50408 fail:
50409 return NULL;
50410 }
50411
50412
50413 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50414 PyObject *resultobj = 0;
50415 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50416 wxWindow *arg2 = (wxWindow *) 0 ;
50417 wxGBPosition result;
50418 void *argp1 = 0 ;
50419 int res1 = 0 ;
50420 void *argp2 = 0 ;
50421 int res2 = 0 ;
50422
50423 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50425 if (!SWIG_IsOK(res1)) {
50426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50427 }
50428 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50429 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50430 if (!SWIG_IsOK(res2)) {
50431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50432 }
50433 arg2 = reinterpret_cast< wxWindow * >(argp2);
50434 {
50435 PyThreadState* __tstate = wxPyBeginAllowThreads();
50436 result = (arg1)->GetItemPosition(arg2);
50437 wxPyEndAllowThreads(__tstate);
50438 if (PyErr_Occurred()) SWIG_fail;
50439 }
50440 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50441 return resultobj;
50442 fail:
50443 return NULL;
50444 }
50445
50446
50447 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50448 PyObject *resultobj = 0;
50449 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50450 wxSizer *arg2 = (wxSizer *) 0 ;
50451 wxGBPosition result;
50452 void *argp1 = 0 ;
50453 int res1 = 0 ;
50454 void *argp2 = 0 ;
50455 int res2 = 0 ;
50456
50457 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50459 if (!SWIG_IsOK(res1)) {
50460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50461 }
50462 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50463 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50464 if (!SWIG_IsOK(res2)) {
50465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50466 }
50467 arg2 = reinterpret_cast< wxSizer * >(argp2);
50468 {
50469 PyThreadState* __tstate = wxPyBeginAllowThreads();
50470 result = (arg1)->GetItemPosition(arg2);
50471 wxPyEndAllowThreads(__tstate);
50472 if (PyErr_Occurred()) SWIG_fail;
50473 }
50474 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50475 return resultobj;
50476 fail:
50477 return NULL;
50478 }
50479
50480
50481 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50482 PyObject *resultobj = 0;
50483 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50484 size_t arg2 ;
50485 wxGBPosition result;
50486 void *argp1 = 0 ;
50487 int res1 = 0 ;
50488 size_t val2 ;
50489 int ecode2 = 0 ;
50490
50491 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50493 if (!SWIG_IsOK(res1)) {
50494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50495 }
50496 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50497 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50498 if (!SWIG_IsOK(ecode2)) {
50499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50500 }
50501 arg2 = static_cast< size_t >(val2);
50502 {
50503 PyThreadState* __tstate = wxPyBeginAllowThreads();
50504 result = (arg1)->GetItemPosition(arg2);
50505 wxPyEndAllowThreads(__tstate);
50506 if (PyErr_Occurred()) SWIG_fail;
50507 }
50508 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50509 return resultobj;
50510 fail:
50511 return NULL;
50512 }
50513
50514
50515 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50516 int argc;
50517 PyObject *argv[3];
50518
50519 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50520 --argc;
50521 if (argc == 2) {
50522 int _v = 0;
50523 {
50524 void *vptr = 0;
50525 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50526 _v = SWIG_CheckState(res);
50527 }
50528 if (!_v) goto check_1;
50529 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50530 }
50531 check_1:
50532
50533 if (argc == 2) {
50534 int _v = 0;
50535 {
50536 void *vptr = 0;
50537 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50538 _v = SWIG_CheckState(res);
50539 }
50540 if (!_v) goto check_2;
50541 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50542 }
50543 check_2:
50544
50545 if (argc == 2) {
50546 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50547 }
50548
50549 fail:
50550 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50551 return NULL;
50552 }
50553
50554
50555 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50556 PyObject *resultobj = 0;
50557 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50558 wxWindow *arg2 = (wxWindow *) 0 ;
50559 wxGBPosition *arg3 = 0 ;
50560 bool result;
50561 void *argp1 = 0 ;
50562 int res1 = 0 ;
50563 void *argp2 = 0 ;
50564 int res2 = 0 ;
50565 wxGBPosition temp3 ;
50566
50567 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50569 if (!SWIG_IsOK(res1)) {
50570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50571 }
50572 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50573 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50574 if (!SWIG_IsOK(res2)) {
50575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50576 }
50577 arg2 = reinterpret_cast< wxWindow * >(argp2);
50578 {
50579 arg3 = &temp3;
50580 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50581 }
50582 {
50583 PyThreadState* __tstate = wxPyBeginAllowThreads();
50584 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50585 wxPyEndAllowThreads(__tstate);
50586 if (PyErr_Occurred()) SWIG_fail;
50587 }
50588 {
50589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50590 }
50591 return resultobj;
50592 fail:
50593 return NULL;
50594 }
50595
50596
50597 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50598 PyObject *resultobj = 0;
50599 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50600 wxSizer *arg2 = (wxSizer *) 0 ;
50601 wxGBPosition *arg3 = 0 ;
50602 bool result;
50603 void *argp1 = 0 ;
50604 int res1 = 0 ;
50605 void *argp2 = 0 ;
50606 int res2 = 0 ;
50607 wxGBPosition temp3 ;
50608
50609 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50611 if (!SWIG_IsOK(res1)) {
50612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50613 }
50614 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50615 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50616 if (!SWIG_IsOK(res2)) {
50617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50618 }
50619 arg2 = reinterpret_cast< wxSizer * >(argp2);
50620 {
50621 arg3 = &temp3;
50622 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50623 }
50624 {
50625 PyThreadState* __tstate = wxPyBeginAllowThreads();
50626 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50627 wxPyEndAllowThreads(__tstate);
50628 if (PyErr_Occurred()) SWIG_fail;
50629 }
50630 {
50631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50632 }
50633 return resultobj;
50634 fail:
50635 return NULL;
50636 }
50637
50638
50639 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50640 PyObject *resultobj = 0;
50641 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50642 size_t arg2 ;
50643 wxGBPosition *arg3 = 0 ;
50644 bool result;
50645 void *argp1 = 0 ;
50646 int res1 = 0 ;
50647 size_t val2 ;
50648 int ecode2 = 0 ;
50649 wxGBPosition temp3 ;
50650
50651 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50653 if (!SWIG_IsOK(res1)) {
50654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50655 }
50656 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50657 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50658 if (!SWIG_IsOK(ecode2)) {
50659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50660 }
50661 arg2 = static_cast< size_t >(val2);
50662 {
50663 arg3 = &temp3;
50664 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50665 }
50666 {
50667 PyThreadState* __tstate = wxPyBeginAllowThreads();
50668 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50669 wxPyEndAllowThreads(__tstate);
50670 if (PyErr_Occurred()) SWIG_fail;
50671 }
50672 {
50673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50674 }
50675 return resultobj;
50676 fail:
50677 return NULL;
50678 }
50679
50680
50681 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50682 int argc;
50683 PyObject *argv[4];
50684
50685 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50686 --argc;
50687 if (argc == 3) {
50688 int _v = 0;
50689 {
50690 void *vptr = 0;
50691 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50692 _v = SWIG_CheckState(res);
50693 }
50694 if (!_v) goto check_1;
50695 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50696 }
50697 check_1:
50698
50699 if (argc == 3) {
50700 int _v = 0;
50701 {
50702 void *vptr = 0;
50703 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50704 _v = SWIG_CheckState(res);
50705 }
50706 if (!_v) goto check_2;
50707 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50708 }
50709 check_2:
50710
50711 if (argc == 3) {
50712 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50713 }
50714
50715 fail:
50716 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50717 return NULL;
50718 }
50719
50720
50721 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50722 PyObject *resultobj = 0;
50723 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50724 wxWindow *arg2 = (wxWindow *) 0 ;
50725 wxGBSpan result;
50726 void *argp1 = 0 ;
50727 int res1 = 0 ;
50728 void *argp2 = 0 ;
50729 int res2 = 0 ;
50730
50731 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50733 if (!SWIG_IsOK(res1)) {
50734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50735 }
50736 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50737 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50738 if (!SWIG_IsOK(res2)) {
50739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50740 }
50741 arg2 = reinterpret_cast< wxWindow * >(argp2);
50742 {
50743 PyThreadState* __tstate = wxPyBeginAllowThreads();
50744 result = (arg1)->GetItemSpan(arg2);
50745 wxPyEndAllowThreads(__tstate);
50746 if (PyErr_Occurred()) SWIG_fail;
50747 }
50748 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50749 return resultobj;
50750 fail:
50751 return NULL;
50752 }
50753
50754
50755 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50756 PyObject *resultobj = 0;
50757 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50758 wxSizer *arg2 = (wxSizer *) 0 ;
50759 wxGBSpan result;
50760 void *argp1 = 0 ;
50761 int res1 = 0 ;
50762 void *argp2 = 0 ;
50763 int res2 = 0 ;
50764
50765 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50767 if (!SWIG_IsOK(res1)) {
50768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50769 }
50770 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50771 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50772 if (!SWIG_IsOK(res2)) {
50773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50774 }
50775 arg2 = reinterpret_cast< wxSizer * >(argp2);
50776 {
50777 PyThreadState* __tstate = wxPyBeginAllowThreads();
50778 result = (arg1)->GetItemSpan(arg2);
50779 wxPyEndAllowThreads(__tstate);
50780 if (PyErr_Occurred()) SWIG_fail;
50781 }
50782 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50783 return resultobj;
50784 fail:
50785 return NULL;
50786 }
50787
50788
50789 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50790 PyObject *resultobj = 0;
50791 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50792 size_t arg2 ;
50793 wxGBSpan result;
50794 void *argp1 = 0 ;
50795 int res1 = 0 ;
50796 size_t val2 ;
50797 int ecode2 = 0 ;
50798
50799 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50801 if (!SWIG_IsOK(res1)) {
50802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50803 }
50804 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50805 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50806 if (!SWIG_IsOK(ecode2)) {
50807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50808 }
50809 arg2 = static_cast< size_t >(val2);
50810 {
50811 PyThreadState* __tstate = wxPyBeginAllowThreads();
50812 result = (arg1)->GetItemSpan(arg2);
50813 wxPyEndAllowThreads(__tstate);
50814 if (PyErr_Occurred()) SWIG_fail;
50815 }
50816 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50817 return resultobj;
50818 fail:
50819 return NULL;
50820 }
50821
50822
50823 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50824 int argc;
50825 PyObject *argv[3];
50826
50827 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50828 --argc;
50829 if (argc == 2) {
50830 int _v = 0;
50831 {
50832 void *vptr = 0;
50833 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50834 _v = SWIG_CheckState(res);
50835 }
50836 if (!_v) goto check_1;
50837 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50838 }
50839 check_1:
50840
50841 if (argc == 2) {
50842 int _v = 0;
50843 {
50844 void *vptr = 0;
50845 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50846 _v = SWIG_CheckState(res);
50847 }
50848 if (!_v) goto check_2;
50849 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50850 }
50851 check_2:
50852
50853 if (argc == 2) {
50854 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50855 }
50856
50857 fail:
50858 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50859 return NULL;
50860 }
50861
50862
50863 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50864 PyObject *resultobj = 0;
50865 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50866 wxWindow *arg2 = (wxWindow *) 0 ;
50867 wxGBSpan *arg3 = 0 ;
50868 bool result;
50869 void *argp1 = 0 ;
50870 int res1 = 0 ;
50871 void *argp2 = 0 ;
50872 int res2 = 0 ;
50873 wxGBSpan temp3 ;
50874
50875 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50877 if (!SWIG_IsOK(res1)) {
50878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50879 }
50880 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50881 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50882 if (!SWIG_IsOK(res2)) {
50883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50884 }
50885 arg2 = reinterpret_cast< wxWindow * >(argp2);
50886 {
50887 arg3 = &temp3;
50888 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50889 }
50890 {
50891 PyThreadState* __tstate = wxPyBeginAllowThreads();
50892 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50893 wxPyEndAllowThreads(__tstate);
50894 if (PyErr_Occurred()) SWIG_fail;
50895 }
50896 {
50897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50898 }
50899 return resultobj;
50900 fail:
50901 return NULL;
50902 }
50903
50904
50905 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50906 PyObject *resultobj = 0;
50907 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50908 wxSizer *arg2 = (wxSizer *) 0 ;
50909 wxGBSpan *arg3 = 0 ;
50910 bool result;
50911 void *argp1 = 0 ;
50912 int res1 = 0 ;
50913 void *argp2 = 0 ;
50914 int res2 = 0 ;
50915 wxGBSpan temp3 ;
50916
50917 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50919 if (!SWIG_IsOK(res1)) {
50920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50921 }
50922 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50923 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50924 if (!SWIG_IsOK(res2)) {
50925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50926 }
50927 arg2 = reinterpret_cast< wxSizer * >(argp2);
50928 {
50929 arg3 = &temp3;
50930 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50931 }
50932 {
50933 PyThreadState* __tstate = wxPyBeginAllowThreads();
50934 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50935 wxPyEndAllowThreads(__tstate);
50936 if (PyErr_Occurred()) SWIG_fail;
50937 }
50938 {
50939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50940 }
50941 return resultobj;
50942 fail:
50943 return NULL;
50944 }
50945
50946
50947 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50948 PyObject *resultobj = 0;
50949 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50950 size_t arg2 ;
50951 wxGBSpan *arg3 = 0 ;
50952 bool result;
50953 void *argp1 = 0 ;
50954 int res1 = 0 ;
50955 size_t val2 ;
50956 int ecode2 = 0 ;
50957 wxGBSpan temp3 ;
50958
50959 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50961 if (!SWIG_IsOK(res1)) {
50962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50963 }
50964 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50965 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50966 if (!SWIG_IsOK(ecode2)) {
50967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50968 }
50969 arg2 = static_cast< size_t >(val2);
50970 {
50971 arg3 = &temp3;
50972 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50973 }
50974 {
50975 PyThreadState* __tstate = wxPyBeginAllowThreads();
50976 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50977 wxPyEndAllowThreads(__tstate);
50978 if (PyErr_Occurred()) SWIG_fail;
50979 }
50980 {
50981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50982 }
50983 return resultobj;
50984 fail:
50985 return NULL;
50986 }
50987
50988
50989 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50990 int argc;
50991 PyObject *argv[4];
50992
50993 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50994 --argc;
50995 if (argc == 3) {
50996 int _v = 0;
50997 {
50998 void *vptr = 0;
50999 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51000 _v = SWIG_CheckState(res);
51001 }
51002 if (!_v) goto check_1;
51003 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51004 }
51005 check_1:
51006
51007 if (argc == 3) {
51008 int _v = 0;
51009 {
51010 void *vptr = 0;
51011 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51012 _v = SWIG_CheckState(res);
51013 }
51014 if (!_v) goto check_2;
51015 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51016 }
51017 check_2:
51018
51019 if (argc == 3) {
51020 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51021 }
51022
51023 fail:
51024 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51025 return NULL;
51026 }
51027
51028
51029 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51030 PyObject *resultobj = 0;
51031 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51032 wxWindow *arg2 = (wxWindow *) 0 ;
51033 wxGBSizerItem *result = 0 ;
51034 void *argp1 = 0 ;
51035 int res1 = 0 ;
51036 void *argp2 = 0 ;
51037 int res2 = 0 ;
51038
51039 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51041 if (!SWIG_IsOK(res1)) {
51042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51043 }
51044 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51045 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51046 if (!SWIG_IsOK(res2)) {
51047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51048 }
51049 arg2 = reinterpret_cast< wxWindow * >(argp2);
51050 {
51051 PyThreadState* __tstate = wxPyBeginAllowThreads();
51052 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51053 wxPyEndAllowThreads(__tstate);
51054 if (PyErr_Occurred()) SWIG_fail;
51055 }
51056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51057 return resultobj;
51058 fail:
51059 return NULL;
51060 }
51061
51062
51063 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51064 PyObject *resultobj = 0;
51065 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51066 wxSizer *arg2 = (wxSizer *) 0 ;
51067 wxGBSizerItem *result = 0 ;
51068 void *argp1 = 0 ;
51069 int res1 = 0 ;
51070 void *argp2 = 0 ;
51071 int res2 = 0 ;
51072
51073 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51075 if (!SWIG_IsOK(res1)) {
51076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51077 }
51078 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51079 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51080 if (!SWIG_IsOK(res2)) {
51081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51082 }
51083 arg2 = reinterpret_cast< wxSizer * >(argp2);
51084 {
51085 PyThreadState* __tstate = wxPyBeginAllowThreads();
51086 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51087 wxPyEndAllowThreads(__tstate);
51088 if (PyErr_Occurred()) SWIG_fail;
51089 }
51090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51091 return resultobj;
51092 fail:
51093 return NULL;
51094 }
51095
51096
51097 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51098 int argc;
51099 PyObject *argv[3];
51100
51101 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51102 --argc;
51103 if (argc == 2) {
51104 int _v = 0;
51105 {
51106 void *vptr = 0;
51107 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51108 _v = SWIG_CheckState(res);
51109 }
51110 if (!_v) goto check_1;
51111 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51112 }
51113 check_1:
51114
51115 if (argc == 2) {
51116 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51117 }
51118
51119 fail:
51120 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51121 return NULL;
51122 }
51123
51124
51125 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51126 PyObject *resultobj = 0;
51127 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51128 wxGBPosition *arg2 = 0 ;
51129 wxGBSizerItem *result = 0 ;
51130 void *argp1 = 0 ;
51131 int res1 = 0 ;
51132 wxGBPosition temp2 ;
51133 PyObject * obj0 = 0 ;
51134 PyObject * obj1 = 0 ;
51135 char * kwnames[] = {
51136 (char *) "self",(char *) "pos", NULL
51137 };
51138
51139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51141 if (!SWIG_IsOK(res1)) {
51142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51143 }
51144 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51145 {
51146 arg2 = &temp2;
51147 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51148 }
51149 {
51150 PyThreadState* __tstate = wxPyBeginAllowThreads();
51151 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51152 wxPyEndAllowThreads(__tstate);
51153 if (PyErr_Occurred()) SWIG_fail;
51154 }
51155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51156 return resultobj;
51157 fail:
51158 return NULL;
51159 }
51160
51161
51162 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51163 PyObject *resultobj = 0;
51164 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51165 wxPoint *arg2 = 0 ;
51166 wxGBSizerItem *result = 0 ;
51167 void *argp1 = 0 ;
51168 int res1 = 0 ;
51169 wxPoint temp2 ;
51170 PyObject * obj0 = 0 ;
51171 PyObject * obj1 = 0 ;
51172 char * kwnames[] = {
51173 (char *) "self",(char *) "pt", NULL
51174 };
51175
51176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51178 if (!SWIG_IsOK(res1)) {
51179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51180 }
51181 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51182 {
51183 arg2 = &temp2;
51184 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51185 }
51186 {
51187 PyThreadState* __tstate = wxPyBeginAllowThreads();
51188 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51189 wxPyEndAllowThreads(__tstate);
51190 if (PyErr_Occurred()) SWIG_fail;
51191 }
51192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51193 return resultobj;
51194 fail:
51195 return NULL;
51196 }
51197
51198
51199 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51200 PyObject *resultobj = 0;
51201 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51202 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51203 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51204 bool result;
51205 void *argp1 = 0 ;
51206 int res1 = 0 ;
51207 void *argp2 = 0 ;
51208 int res2 = 0 ;
51209 void *argp3 = 0 ;
51210 int res3 = 0 ;
51211 PyObject * obj0 = 0 ;
51212 PyObject * obj1 = 0 ;
51213 PyObject * obj2 = 0 ;
51214 char * kwnames[] = {
51215 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51216 };
51217
51218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51220 if (!SWIG_IsOK(res1)) {
51221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51222 }
51223 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51225 if (!SWIG_IsOK(res2)) {
51226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51227 }
51228 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51229 if (obj2) {
51230 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51231 if (!SWIG_IsOK(res3)) {
51232 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51233 }
51234 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51235 }
51236 {
51237 PyThreadState* __tstate = wxPyBeginAllowThreads();
51238 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51239 wxPyEndAllowThreads(__tstate);
51240 if (PyErr_Occurred()) SWIG_fail;
51241 }
51242 {
51243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51244 }
51245 return resultobj;
51246 fail:
51247 return NULL;
51248 }
51249
51250
51251 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51252 PyObject *resultobj = 0;
51253 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51254 wxGBPosition *arg2 = 0 ;
51255 wxGBSpan *arg3 = 0 ;
51256 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51257 bool result;
51258 void *argp1 = 0 ;
51259 int res1 = 0 ;
51260 wxGBPosition temp2 ;
51261 wxGBSpan temp3 ;
51262 void *argp4 = 0 ;
51263 int res4 = 0 ;
51264 PyObject * obj0 = 0 ;
51265 PyObject * obj1 = 0 ;
51266 PyObject * obj2 = 0 ;
51267 PyObject * obj3 = 0 ;
51268 char * kwnames[] = {
51269 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51270 };
51271
51272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51274 if (!SWIG_IsOK(res1)) {
51275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51276 }
51277 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51278 {
51279 arg2 = &temp2;
51280 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51281 }
51282 {
51283 arg3 = &temp3;
51284 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51285 }
51286 if (obj3) {
51287 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51288 if (!SWIG_IsOK(res4)) {
51289 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51290 }
51291 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51292 }
51293 {
51294 PyThreadState* __tstate = wxPyBeginAllowThreads();
51295 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51296 wxPyEndAllowThreads(__tstate);
51297 if (PyErr_Occurred()) SWIG_fail;
51298 }
51299 {
51300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51301 }
51302 return resultobj;
51303 fail:
51304 return NULL;
51305 }
51306
51307
51308 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51309 PyObject *obj;
51310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51311 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51312 return SWIG_Py_Void();
51313 }
51314
51315 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51316 return SWIG_Python_InitShadowInstance(args);
51317 }
51318
51319 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51320 PyObject *resultobj = 0;
51321 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51322 wxRelationship arg2 ;
51323 wxWindow *arg3 = (wxWindow *) 0 ;
51324 wxEdge arg4 ;
51325 int arg5 = (int) 0 ;
51326 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51327 void *argp1 = 0 ;
51328 int res1 = 0 ;
51329 int val2 ;
51330 int ecode2 = 0 ;
51331 void *argp3 = 0 ;
51332 int res3 = 0 ;
51333 int val4 ;
51334 int ecode4 = 0 ;
51335 int val5 ;
51336 int ecode5 = 0 ;
51337 int val6 ;
51338 int ecode6 = 0 ;
51339 PyObject * obj0 = 0 ;
51340 PyObject * obj1 = 0 ;
51341 PyObject * obj2 = 0 ;
51342 PyObject * obj3 = 0 ;
51343 PyObject * obj4 = 0 ;
51344 PyObject * obj5 = 0 ;
51345 char * kwnames[] = {
51346 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51347 };
51348
51349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51351 if (!SWIG_IsOK(res1)) {
51352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51353 }
51354 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51355 ecode2 = SWIG_AsVal_int(obj1, &val2);
51356 if (!SWIG_IsOK(ecode2)) {
51357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51358 }
51359 arg2 = static_cast< wxRelationship >(val2);
51360 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51361 if (!SWIG_IsOK(res3)) {
51362 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51363 }
51364 arg3 = reinterpret_cast< wxWindow * >(argp3);
51365 ecode4 = SWIG_AsVal_int(obj3, &val4);
51366 if (!SWIG_IsOK(ecode4)) {
51367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51368 }
51369 arg4 = static_cast< wxEdge >(val4);
51370 if (obj4) {
51371 ecode5 = SWIG_AsVal_int(obj4, &val5);
51372 if (!SWIG_IsOK(ecode5)) {
51373 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51374 }
51375 arg5 = static_cast< int >(val5);
51376 }
51377 if (obj5) {
51378 ecode6 = SWIG_AsVal_int(obj5, &val6);
51379 if (!SWIG_IsOK(ecode6)) {
51380 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51381 }
51382 arg6 = static_cast< int >(val6);
51383 }
51384 {
51385 PyThreadState* __tstate = wxPyBeginAllowThreads();
51386 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51387 wxPyEndAllowThreads(__tstate);
51388 if (PyErr_Occurred()) SWIG_fail;
51389 }
51390 resultobj = SWIG_Py_Void();
51391 return resultobj;
51392 fail:
51393 return NULL;
51394 }
51395
51396
51397 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51398 PyObject *resultobj = 0;
51399 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51400 wxWindow *arg2 = (wxWindow *) 0 ;
51401 int arg3 = (int) 0 ;
51402 void *argp1 = 0 ;
51403 int res1 = 0 ;
51404 void *argp2 = 0 ;
51405 int res2 = 0 ;
51406 int val3 ;
51407 int ecode3 = 0 ;
51408 PyObject * obj0 = 0 ;
51409 PyObject * obj1 = 0 ;
51410 PyObject * obj2 = 0 ;
51411 char * kwnames[] = {
51412 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51413 };
51414
51415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51417 if (!SWIG_IsOK(res1)) {
51418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51419 }
51420 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51422 if (!SWIG_IsOK(res2)) {
51423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51424 }
51425 arg2 = reinterpret_cast< wxWindow * >(argp2);
51426 if (obj2) {
51427 ecode3 = SWIG_AsVal_int(obj2, &val3);
51428 if (!SWIG_IsOK(ecode3)) {
51429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51430 }
51431 arg3 = static_cast< int >(val3);
51432 }
51433 {
51434 PyThreadState* __tstate = wxPyBeginAllowThreads();
51435 (arg1)->LeftOf(arg2,arg3);
51436 wxPyEndAllowThreads(__tstate);
51437 if (PyErr_Occurred()) SWIG_fail;
51438 }
51439 resultobj = SWIG_Py_Void();
51440 return resultobj;
51441 fail:
51442 return NULL;
51443 }
51444
51445
51446 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51447 PyObject *resultobj = 0;
51448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51449 wxWindow *arg2 = (wxWindow *) 0 ;
51450 int arg3 = (int) 0 ;
51451 void *argp1 = 0 ;
51452 int res1 = 0 ;
51453 void *argp2 = 0 ;
51454 int res2 = 0 ;
51455 int val3 ;
51456 int ecode3 = 0 ;
51457 PyObject * obj0 = 0 ;
51458 PyObject * obj1 = 0 ;
51459 PyObject * obj2 = 0 ;
51460 char * kwnames[] = {
51461 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51462 };
51463
51464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51466 if (!SWIG_IsOK(res1)) {
51467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51468 }
51469 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51471 if (!SWIG_IsOK(res2)) {
51472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51473 }
51474 arg2 = reinterpret_cast< wxWindow * >(argp2);
51475 if (obj2) {
51476 ecode3 = SWIG_AsVal_int(obj2, &val3);
51477 if (!SWIG_IsOK(ecode3)) {
51478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51479 }
51480 arg3 = static_cast< int >(val3);
51481 }
51482 {
51483 PyThreadState* __tstate = wxPyBeginAllowThreads();
51484 (arg1)->RightOf(arg2,arg3);
51485 wxPyEndAllowThreads(__tstate);
51486 if (PyErr_Occurred()) SWIG_fail;
51487 }
51488 resultobj = SWIG_Py_Void();
51489 return resultobj;
51490 fail:
51491 return NULL;
51492 }
51493
51494
51495 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51496 PyObject *resultobj = 0;
51497 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51498 wxWindow *arg2 = (wxWindow *) 0 ;
51499 int arg3 = (int) 0 ;
51500 void *argp1 = 0 ;
51501 int res1 = 0 ;
51502 void *argp2 = 0 ;
51503 int res2 = 0 ;
51504 int val3 ;
51505 int ecode3 = 0 ;
51506 PyObject * obj0 = 0 ;
51507 PyObject * obj1 = 0 ;
51508 PyObject * obj2 = 0 ;
51509 char * kwnames[] = {
51510 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51511 };
51512
51513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51515 if (!SWIG_IsOK(res1)) {
51516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51517 }
51518 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51519 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51520 if (!SWIG_IsOK(res2)) {
51521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51522 }
51523 arg2 = reinterpret_cast< wxWindow * >(argp2);
51524 if (obj2) {
51525 ecode3 = SWIG_AsVal_int(obj2, &val3);
51526 if (!SWIG_IsOK(ecode3)) {
51527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51528 }
51529 arg3 = static_cast< int >(val3);
51530 }
51531 {
51532 PyThreadState* __tstate = wxPyBeginAllowThreads();
51533 (arg1)->Above(arg2,arg3);
51534 wxPyEndAllowThreads(__tstate);
51535 if (PyErr_Occurred()) SWIG_fail;
51536 }
51537 resultobj = SWIG_Py_Void();
51538 return resultobj;
51539 fail:
51540 return NULL;
51541 }
51542
51543
51544 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51545 PyObject *resultobj = 0;
51546 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51547 wxWindow *arg2 = (wxWindow *) 0 ;
51548 int arg3 = (int) 0 ;
51549 void *argp1 = 0 ;
51550 int res1 = 0 ;
51551 void *argp2 = 0 ;
51552 int res2 = 0 ;
51553 int val3 ;
51554 int ecode3 = 0 ;
51555 PyObject * obj0 = 0 ;
51556 PyObject * obj1 = 0 ;
51557 PyObject * obj2 = 0 ;
51558 char * kwnames[] = {
51559 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51560 };
51561
51562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51564 if (!SWIG_IsOK(res1)) {
51565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51566 }
51567 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51568 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51569 if (!SWIG_IsOK(res2)) {
51570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51571 }
51572 arg2 = reinterpret_cast< wxWindow * >(argp2);
51573 if (obj2) {
51574 ecode3 = SWIG_AsVal_int(obj2, &val3);
51575 if (!SWIG_IsOK(ecode3)) {
51576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51577 }
51578 arg3 = static_cast< int >(val3);
51579 }
51580 {
51581 PyThreadState* __tstate = wxPyBeginAllowThreads();
51582 (arg1)->Below(arg2,arg3);
51583 wxPyEndAllowThreads(__tstate);
51584 if (PyErr_Occurred()) SWIG_fail;
51585 }
51586 resultobj = SWIG_Py_Void();
51587 return resultobj;
51588 fail:
51589 return NULL;
51590 }
51591
51592
51593 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51594 PyObject *resultobj = 0;
51595 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51596 wxWindow *arg2 = (wxWindow *) 0 ;
51597 wxEdge arg3 ;
51598 int arg4 = (int) 0 ;
51599 void *argp1 = 0 ;
51600 int res1 = 0 ;
51601 void *argp2 = 0 ;
51602 int res2 = 0 ;
51603 int val3 ;
51604 int ecode3 = 0 ;
51605 int val4 ;
51606 int ecode4 = 0 ;
51607 PyObject * obj0 = 0 ;
51608 PyObject * obj1 = 0 ;
51609 PyObject * obj2 = 0 ;
51610 PyObject * obj3 = 0 ;
51611 char * kwnames[] = {
51612 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51613 };
51614
51615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51617 if (!SWIG_IsOK(res1)) {
51618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51619 }
51620 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51622 if (!SWIG_IsOK(res2)) {
51623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51624 }
51625 arg2 = reinterpret_cast< wxWindow * >(argp2);
51626 ecode3 = SWIG_AsVal_int(obj2, &val3);
51627 if (!SWIG_IsOK(ecode3)) {
51628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51629 }
51630 arg3 = static_cast< wxEdge >(val3);
51631 if (obj3) {
51632 ecode4 = SWIG_AsVal_int(obj3, &val4);
51633 if (!SWIG_IsOK(ecode4)) {
51634 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51635 }
51636 arg4 = static_cast< int >(val4);
51637 }
51638 {
51639 PyThreadState* __tstate = wxPyBeginAllowThreads();
51640 (arg1)->SameAs(arg2,arg3,arg4);
51641 wxPyEndAllowThreads(__tstate);
51642 if (PyErr_Occurred()) SWIG_fail;
51643 }
51644 resultobj = SWIG_Py_Void();
51645 return resultobj;
51646 fail:
51647 return NULL;
51648 }
51649
51650
51651 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51652 PyObject *resultobj = 0;
51653 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51654 wxWindow *arg2 = (wxWindow *) 0 ;
51655 wxEdge arg3 ;
51656 int arg4 ;
51657 void *argp1 = 0 ;
51658 int res1 = 0 ;
51659 void *argp2 = 0 ;
51660 int res2 = 0 ;
51661 int val3 ;
51662 int ecode3 = 0 ;
51663 int val4 ;
51664 int ecode4 = 0 ;
51665 PyObject * obj0 = 0 ;
51666 PyObject * obj1 = 0 ;
51667 PyObject * obj2 = 0 ;
51668 PyObject * obj3 = 0 ;
51669 char * kwnames[] = {
51670 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51671 };
51672
51673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51675 if (!SWIG_IsOK(res1)) {
51676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51677 }
51678 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51680 if (!SWIG_IsOK(res2)) {
51681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51682 }
51683 arg2 = reinterpret_cast< wxWindow * >(argp2);
51684 ecode3 = SWIG_AsVal_int(obj2, &val3);
51685 if (!SWIG_IsOK(ecode3)) {
51686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51687 }
51688 arg3 = static_cast< wxEdge >(val3);
51689 ecode4 = SWIG_AsVal_int(obj3, &val4);
51690 if (!SWIG_IsOK(ecode4)) {
51691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51692 }
51693 arg4 = static_cast< int >(val4);
51694 {
51695 PyThreadState* __tstate = wxPyBeginAllowThreads();
51696 (arg1)->PercentOf(arg2,arg3,arg4);
51697 wxPyEndAllowThreads(__tstate);
51698 if (PyErr_Occurred()) SWIG_fail;
51699 }
51700 resultobj = SWIG_Py_Void();
51701 return resultobj;
51702 fail:
51703 return NULL;
51704 }
51705
51706
51707 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51708 PyObject *resultobj = 0;
51709 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51710 int arg2 ;
51711 void *argp1 = 0 ;
51712 int res1 = 0 ;
51713 int val2 ;
51714 int ecode2 = 0 ;
51715 PyObject * obj0 = 0 ;
51716 PyObject * obj1 = 0 ;
51717 char * kwnames[] = {
51718 (char *) "self",(char *) "val", NULL
51719 };
51720
51721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51723 if (!SWIG_IsOK(res1)) {
51724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51725 }
51726 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51727 ecode2 = SWIG_AsVal_int(obj1, &val2);
51728 if (!SWIG_IsOK(ecode2)) {
51729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51730 }
51731 arg2 = static_cast< int >(val2);
51732 {
51733 PyThreadState* __tstate = wxPyBeginAllowThreads();
51734 (arg1)->Absolute(arg2);
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_Unconstrained(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_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51757 }
51758 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51759 {
51760 PyThreadState* __tstate = wxPyBeginAllowThreads();
51761 (arg1)->Unconstrained();
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_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51773 PyObject *resultobj = 0;
51774 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51775 void *argp1 = 0 ;
51776 int res1 = 0 ;
51777 PyObject *swig_obj[1] ;
51778
51779 if (!args) SWIG_fail;
51780 swig_obj[0] = args;
51781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51782 if (!SWIG_IsOK(res1)) {
51783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51784 }
51785 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51786 {
51787 PyThreadState* __tstate = wxPyBeginAllowThreads();
51788 (arg1)->AsIs();
51789 wxPyEndAllowThreads(__tstate);
51790 if (PyErr_Occurred()) SWIG_fail;
51791 }
51792 resultobj = SWIG_Py_Void();
51793 return resultobj;
51794 fail:
51795 return NULL;
51796 }
51797
51798
51799 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51800 PyObject *resultobj = 0;
51801 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51802 wxWindow *result = 0 ;
51803 void *argp1 = 0 ;
51804 int res1 = 0 ;
51805 PyObject *swig_obj[1] ;
51806
51807 if (!args) SWIG_fail;
51808 swig_obj[0] = args;
51809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51810 if (!SWIG_IsOK(res1)) {
51811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51812 }
51813 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51814 {
51815 PyThreadState* __tstate = wxPyBeginAllowThreads();
51816 result = (wxWindow *)(arg1)->GetOtherWindow();
51817 wxPyEndAllowThreads(__tstate);
51818 if (PyErr_Occurred()) SWIG_fail;
51819 }
51820 {
51821 resultobj = wxPyMake_wxObject(result, 0);
51822 }
51823 return resultobj;
51824 fail:
51825 return NULL;
51826 }
51827
51828
51829 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51830 PyObject *resultobj = 0;
51831 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51832 wxEdge result;
51833 void *argp1 = 0 ;
51834 int res1 = 0 ;
51835 PyObject *swig_obj[1] ;
51836
51837 if (!args) SWIG_fail;
51838 swig_obj[0] = args;
51839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51840 if (!SWIG_IsOK(res1)) {
51841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51842 }
51843 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51844 {
51845 PyThreadState* __tstate = wxPyBeginAllowThreads();
51846 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51847 wxPyEndAllowThreads(__tstate);
51848 if (PyErr_Occurred()) SWIG_fail;
51849 }
51850 resultobj = SWIG_From_int(static_cast< int >(result));
51851 return resultobj;
51852 fail:
51853 return NULL;
51854 }
51855
51856
51857 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51858 PyObject *resultobj = 0;
51859 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51860 wxEdge arg2 ;
51861 void *argp1 = 0 ;
51862 int res1 = 0 ;
51863 int val2 ;
51864 int ecode2 = 0 ;
51865 PyObject * obj0 = 0 ;
51866 PyObject * obj1 = 0 ;
51867 char * kwnames[] = {
51868 (char *) "self",(char *) "which", NULL
51869 };
51870
51871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51873 if (!SWIG_IsOK(res1)) {
51874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51875 }
51876 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51877 ecode2 = SWIG_AsVal_int(obj1, &val2);
51878 if (!SWIG_IsOK(ecode2)) {
51879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51880 }
51881 arg2 = static_cast< wxEdge >(val2);
51882 {
51883 PyThreadState* __tstate = wxPyBeginAllowThreads();
51884 (arg1)->SetEdge(arg2);
51885 wxPyEndAllowThreads(__tstate);
51886 if (PyErr_Occurred()) SWIG_fail;
51887 }
51888 resultobj = SWIG_Py_Void();
51889 return resultobj;
51890 fail:
51891 return NULL;
51892 }
51893
51894
51895 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51896 PyObject *resultobj = 0;
51897 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51898 int arg2 ;
51899 void *argp1 = 0 ;
51900 int res1 = 0 ;
51901 int val2 ;
51902 int ecode2 = 0 ;
51903 PyObject * obj0 = 0 ;
51904 PyObject * obj1 = 0 ;
51905 char * kwnames[] = {
51906 (char *) "self",(char *) "v", NULL
51907 };
51908
51909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51911 if (!SWIG_IsOK(res1)) {
51912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51913 }
51914 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51915 ecode2 = SWIG_AsVal_int(obj1, &val2);
51916 if (!SWIG_IsOK(ecode2)) {
51917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51918 }
51919 arg2 = static_cast< int >(val2);
51920 {
51921 PyThreadState* __tstate = wxPyBeginAllowThreads();
51922 (arg1)->SetValue(arg2);
51923 wxPyEndAllowThreads(__tstate);
51924 if (PyErr_Occurred()) SWIG_fail;
51925 }
51926 resultobj = SWIG_Py_Void();
51927 return resultobj;
51928 fail:
51929 return NULL;
51930 }
51931
51932
51933 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51934 PyObject *resultobj = 0;
51935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51936 int result;
51937 void *argp1 = 0 ;
51938 int res1 = 0 ;
51939 PyObject *swig_obj[1] ;
51940
51941 if (!args) SWIG_fail;
51942 swig_obj[0] = args;
51943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51944 if (!SWIG_IsOK(res1)) {
51945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51946 }
51947 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51948 {
51949 PyThreadState* __tstate = wxPyBeginAllowThreads();
51950 result = (int)(arg1)->GetMargin();
51951 wxPyEndAllowThreads(__tstate);
51952 if (PyErr_Occurred()) SWIG_fail;
51953 }
51954 resultobj = SWIG_From_int(static_cast< int >(result));
51955 return resultobj;
51956 fail:
51957 return NULL;
51958 }
51959
51960
51961 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51962 PyObject *resultobj = 0;
51963 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51964 int arg2 ;
51965 void *argp1 = 0 ;
51966 int res1 = 0 ;
51967 int val2 ;
51968 int ecode2 = 0 ;
51969 PyObject * obj0 = 0 ;
51970 PyObject * obj1 = 0 ;
51971 char * kwnames[] = {
51972 (char *) "self",(char *) "m", NULL
51973 };
51974
51975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51977 if (!SWIG_IsOK(res1)) {
51978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51979 }
51980 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51981 ecode2 = SWIG_AsVal_int(obj1, &val2);
51982 if (!SWIG_IsOK(ecode2)) {
51983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51984 }
51985 arg2 = static_cast< int >(val2);
51986 {
51987 PyThreadState* __tstate = wxPyBeginAllowThreads();
51988 (arg1)->SetMargin(arg2);
51989 wxPyEndAllowThreads(__tstate);
51990 if (PyErr_Occurred()) SWIG_fail;
51991 }
51992 resultobj = SWIG_Py_Void();
51993 return resultobj;
51994 fail:
51995 return NULL;
51996 }
51997
51998
51999 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52000 PyObject *resultobj = 0;
52001 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52002 int result;
52003 void *argp1 = 0 ;
52004 int res1 = 0 ;
52005 PyObject *swig_obj[1] ;
52006
52007 if (!args) SWIG_fail;
52008 swig_obj[0] = args;
52009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52010 if (!SWIG_IsOK(res1)) {
52011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52012 }
52013 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52014 {
52015 PyThreadState* __tstate = wxPyBeginAllowThreads();
52016 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52017 wxPyEndAllowThreads(__tstate);
52018 if (PyErr_Occurred()) SWIG_fail;
52019 }
52020 resultobj = SWIG_From_int(static_cast< int >(result));
52021 return resultobj;
52022 fail:
52023 return NULL;
52024 }
52025
52026
52027 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52028 PyObject *resultobj = 0;
52029 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52030 int result;
52031 void *argp1 = 0 ;
52032 int res1 = 0 ;
52033 PyObject *swig_obj[1] ;
52034
52035 if (!args) SWIG_fail;
52036 swig_obj[0] = args;
52037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52038 if (!SWIG_IsOK(res1)) {
52039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52040 }
52041 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52042 {
52043 PyThreadState* __tstate = wxPyBeginAllowThreads();
52044 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52045 wxPyEndAllowThreads(__tstate);
52046 if (PyErr_Occurred()) SWIG_fail;
52047 }
52048 resultobj = SWIG_From_int(static_cast< int >(result));
52049 return resultobj;
52050 fail:
52051 return NULL;
52052 }
52053
52054
52055 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52056 PyObject *resultobj = 0;
52057 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52058 int result;
52059 void *argp1 = 0 ;
52060 int res1 = 0 ;
52061 PyObject *swig_obj[1] ;
52062
52063 if (!args) SWIG_fail;
52064 swig_obj[0] = args;
52065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52066 if (!SWIG_IsOK(res1)) {
52067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52068 }
52069 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52070 {
52071 PyThreadState* __tstate = wxPyBeginAllowThreads();
52072 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52073 wxPyEndAllowThreads(__tstate);
52074 if (PyErr_Occurred()) SWIG_fail;
52075 }
52076 resultobj = SWIG_From_int(static_cast< int >(result));
52077 return resultobj;
52078 fail:
52079 return NULL;
52080 }
52081
52082
52083 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52084 PyObject *resultobj = 0;
52085 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52086 bool result;
52087 void *argp1 = 0 ;
52088 int res1 = 0 ;
52089 PyObject *swig_obj[1] ;
52090
52091 if (!args) SWIG_fail;
52092 swig_obj[0] = args;
52093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52094 if (!SWIG_IsOK(res1)) {
52095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52096 }
52097 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52098 {
52099 PyThreadState* __tstate = wxPyBeginAllowThreads();
52100 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52101 wxPyEndAllowThreads(__tstate);
52102 if (PyErr_Occurred()) SWIG_fail;
52103 }
52104 {
52105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52106 }
52107 return resultobj;
52108 fail:
52109 return NULL;
52110 }
52111
52112
52113 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52114 PyObject *resultobj = 0;
52115 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52116 bool arg2 ;
52117 void *argp1 = 0 ;
52118 int res1 = 0 ;
52119 bool val2 ;
52120 int ecode2 = 0 ;
52121 PyObject * obj0 = 0 ;
52122 PyObject * obj1 = 0 ;
52123 char * kwnames[] = {
52124 (char *) "self",(char *) "d", NULL
52125 };
52126
52127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52129 if (!SWIG_IsOK(res1)) {
52130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52131 }
52132 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52133 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52134 if (!SWIG_IsOK(ecode2)) {
52135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52136 }
52137 arg2 = static_cast< bool >(val2);
52138 {
52139 PyThreadState* __tstate = wxPyBeginAllowThreads();
52140 (arg1)->SetDone(arg2);
52141 wxPyEndAllowThreads(__tstate);
52142 if (PyErr_Occurred()) SWIG_fail;
52143 }
52144 resultobj = SWIG_Py_Void();
52145 return resultobj;
52146 fail:
52147 return NULL;
52148 }
52149
52150
52151 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52152 PyObject *resultobj = 0;
52153 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52154 wxRelationship result;
52155 void *argp1 = 0 ;
52156 int res1 = 0 ;
52157 PyObject *swig_obj[1] ;
52158
52159 if (!args) SWIG_fail;
52160 swig_obj[0] = args;
52161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52162 if (!SWIG_IsOK(res1)) {
52163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52164 }
52165 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52166 {
52167 PyThreadState* __tstate = wxPyBeginAllowThreads();
52168 result = (wxRelationship)(arg1)->GetRelationship();
52169 wxPyEndAllowThreads(__tstate);
52170 if (PyErr_Occurred()) SWIG_fail;
52171 }
52172 resultobj = SWIG_From_int(static_cast< int >(result));
52173 return resultobj;
52174 fail:
52175 return NULL;
52176 }
52177
52178
52179 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52180 PyObject *resultobj = 0;
52181 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52182 wxRelationship arg2 ;
52183 void *argp1 = 0 ;
52184 int res1 = 0 ;
52185 int val2 ;
52186 int ecode2 = 0 ;
52187 PyObject * obj0 = 0 ;
52188 PyObject * obj1 = 0 ;
52189 char * kwnames[] = {
52190 (char *) "self",(char *) "r", NULL
52191 };
52192
52193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52195 if (!SWIG_IsOK(res1)) {
52196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52197 }
52198 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52199 ecode2 = SWIG_AsVal_int(obj1, &val2);
52200 if (!SWIG_IsOK(ecode2)) {
52201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52202 }
52203 arg2 = static_cast< wxRelationship >(val2);
52204 {
52205 PyThreadState* __tstate = wxPyBeginAllowThreads();
52206 (arg1)->SetRelationship(arg2);
52207 wxPyEndAllowThreads(__tstate);
52208 if (PyErr_Occurred()) SWIG_fail;
52209 }
52210 resultobj = SWIG_Py_Void();
52211 return resultobj;
52212 fail:
52213 return NULL;
52214 }
52215
52216
52217 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52218 PyObject *resultobj = 0;
52219 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52220 wxWindow *arg2 = (wxWindow *) 0 ;
52221 bool result;
52222 void *argp1 = 0 ;
52223 int res1 = 0 ;
52224 void *argp2 = 0 ;
52225 int res2 = 0 ;
52226 PyObject * obj0 = 0 ;
52227 PyObject * obj1 = 0 ;
52228 char * kwnames[] = {
52229 (char *) "self",(char *) "otherW", NULL
52230 };
52231
52232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52234 if (!SWIG_IsOK(res1)) {
52235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52236 }
52237 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52238 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52239 if (!SWIG_IsOK(res2)) {
52240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52241 }
52242 arg2 = reinterpret_cast< wxWindow * >(argp2);
52243 {
52244 PyThreadState* __tstate = wxPyBeginAllowThreads();
52245 result = (bool)(arg1)->ResetIfWin(arg2);
52246 wxPyEndAllowThreads(__tstate);
52247 if (PyErr_Occurred()) SWIG_fail;
52248 }
52249 {
52250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52251 }
52252 return resultobj;
52253 fail:
52254 return NULL;
52255 }
52256
52257
52258 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52259 PyObject *resultobj = 0;
52260 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52261 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52262 wxWindow *arg3 = (wxWindow *) 0 ;
52263 bool result;
52264 void *argp1 = 0 ;
52265 int res1 = 0 ;
52266 void *argp2 = 0 ;
52267 int res2 = 0 ;
52268 void *argp3 = 0 ;
52269 int res3 = 0 ;
52270 PyObject * obj0 = 0 ;
52271 PyObject * obj1 = 0 ;
52272 PyObject * obj2 = 0 ;
52273 char * kwnames[] = {
52274 (char *) "self",(char *) "constraints",(char *) "win", NULL
52275 };
52276
52277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52279 if (!SWIG_IsOK(res1)) {
52280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52281 }
52282 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52284 if (!SWIG_IsOK(res2)) {
52285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52286 }
52287 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52288 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52289 if (!SWIG_IsOK(res3)) {
52290 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52291 }
52292 arg3 = reinterpret_cast< wxWindow * >(argp3);
52293 {
52294 PyThreadState* __tstate = wxPyBeginAllowThreads();
52295 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52296 wxPyEndAllowThreads(__tstate);
52297 if (PyErr_Occurred()) SWIG_fail;
52298 }
52299 {
52300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52301 }
52302 return resultobj;
52303 fail:
52304 return NULL;
52305 }
52306
52307
52308 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52309 PyObject *resultobj = 0;
52310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52311 wxEdge arg2 ;
52312 wxWindow *arg3 = (wxWindow *) 0 ;
52313 wxWindow *arg4 = (wxWindow *) 0 ;
52314 int result;
52315 void *argp1 = 0 ;
52316 int res1 = 0 ;
52317 int val2 ;
52318 int ecode2 = 0 ;
52319 void *argp3 = 0 ;
52320 int res3 = 0 ;
52321 void *argp4 = 0 ;
52322 int res4 = 0 ;
52323 PyObject * obj0 = 0 ;
52324 PyObject * obj1 = 0 ;
52325 PyObject * obj2 = 0 ;
52326 PyObject * obj3 = 0 ;
52327 char * kwnames[] = {
52328 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52329 };
52330
52331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52333 if (!SWIG_IsOK(res1)) {
52334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52335 }
52336 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52337 ecode2 = SWIG_AsVal_int(obj1, &val2);
52338 if (!SWIG_IsOK(ecode2)) {
52339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52340 }
52341 arg2 = static_cast< wxEdge >(val2);
52342 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52343 if (!SWIG_IsOK(res3)) {
52344 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52345 }
52346 arg3 = reinterpret_cast< wxWindow * >(argp3);
52347 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52348 if (!SWIG_IsOK(res4)) {
52349 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52350 }
52351 arg4 = reinterpret_cast< wxWindow * >(argp4);
52352 {
52353 PyThreadState* __tstate = wxPyBeginAllowThreads();
52354 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52355 wxPyEndAllowThreads(__tstate);
52356 if (PyErr_Occurred()) SWIG_fail;
52357 }
52358 resultobj = SWIG_From_int(static_cast< int >(result));
52359 return resultobj;
52360 fail:
52361 return NULL;
52362 }
52363
52364
52365 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52366 PyObject *obj;
52367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52368 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52369 return SWIG_Py_Void();
52370 }
52371
52372 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52373 PyObject *resultobj = 0;
52374 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52375 wxIndividualLayoutConstraint *result = 0 ;
52376 void *argp1 = 0 ;
52377 int res1 = 0 ;
52378 PyObject *swig_obj[1] ;
52379
52380 if (!args) SWIG_fail;
52381 swig_obj[0] = args;
52382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52383 if (!SWIG_IsOK(res1)) {
52384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52385 }
52386 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52387 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52389 return resultobj;
52390 fail:
52391 return NULL;
52392 }
52393
52394
52395 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52396 PyObject *resultobj = 0;
52397 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52398 wxIndividualLayoutConstraint *result = 0 ;
52399 void *argp1 = 0 ;
52400 int res1 = 0 ;
52401 PyObject *swig_obj[1] ;
52402
52403 if (!args) SWIG_fail;
52404 swig_obj[0] = args;
52405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52406 if (!SWIG_IsOK(res1)) {
52407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52408 }
52409 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52410 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52412 return resultobj;
52413 fail:
52414 return NULL;
52415 }
52416
52417
52418 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52419 PyObject *resultobj = 0;
52420 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52421 wxIndividualLayoutConstraint *result = 0 ;
52422 void *argp1 = 0 ;
52423 int res1 = 0 ;
52424 PyObject *swig_obj[1] ;
52425
52426 if (!args) SWIG_fail;
52427 swig_obj[0] = args;
52428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52429 if (!SWIG_IsOK(res1)) {
52430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52431 }
52432 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52433 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52435 return resultobj;
52436 fail:
52437 return NULL;
52438 }
52439
52440
52441 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52442 PyObject *resultobj = 0;
52443 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52444 wxIndividualLayoutConstraint *result = 0 ;
52445 void *argp1 = 0 ;
52446 int res1 = 0 ;
52447 PyObject *swig_obj[1] ;
52448
52449 if (!args) SWIG_fail;
52450 swig_obj[0] = args;
52451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52452 if (!SWIG_IsOK(res1)) {
52453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52454 }
52455 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52456 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52458 return resultobj;
52459 fail:
52460 return NULL;
52461 }
52462
52463
52464 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52465 PyObject *resultobj = 0;
52466 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52467 wxIndividualLayoutConstraint *result = 0 ;
52468 void *argp1 = 0 ;
52469 int res1 = 0 ;
52470 PyObject *swig_obj[1] ;
52471
52472 if (!args) SWIG_fail;
52473 swig_obj[0] = args;
52474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52475 if (!SWIG_IsOK(res1)) {
52476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52477 }
52478 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52479 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52481 return resultobj;
52482 fail:
52483 return NULL;
52484 }
52485
52486
52487 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52488 PyObject *resultobj = 0;
52489 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52490 wxIndividualLayoutConstraint *result = 0 ;
52491 void *argp1 = 0 ;
52492 int res1 = 0 ;
52493 PyObject *swig_obj[1] ;
52494
52495 if (!args) SWIG_fail;
52496 swig_obj[0] = args;
52497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52498 if (!SWIG_IsOK(res1)) {
52499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52500 }
52501 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52502 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52504 return resultobj;
52505 fail:
52506 return NULL;
52507 }
52508
52509
52510 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52511 PyObject *resultobj = 0;
52512 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52513 wxIndividualLayoutConstraint *result = 0 ;
52514 void *argp1 = 0 ;
52515 int res1 = 0 ;
52516 PyObject *swig_obj[1] ;
52517
52518 if (!args) SWIG_fail;
52519 swig_obj[0] = args;
52520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52521 if (!SWIG_IsOK(res1)) {
52522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52523 }
52524 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52525 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52527 return resultobj;
52528 fail:
52529 return NULL;
52530 }
52531
52532
52533 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52534 PyObject *resultobj = 0;
52535 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52536 wxIndividualLayoutConstraint *result = 0 ;
52537 void *argp1 = 0 ;
52538 int res1 = 0 ;
52539 PyObject *swig_obj[1] ;
52540
52541 if (!args) SWIG_fail;
52542 swig_obj[0] = args;
52543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52544 if (!SWIG_IsOK(res1)) {
52545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52546 }
52547 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52548 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52550 return resultobj;
52551 fail:
52552 return NULL;
52553 }
52554
52555
52556 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52557 PyObject *resultobj = 0;
52558 wxLayoutConstraints *result = 0 ;
52559
52560 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52561 {
52562 PyThreadState* __tstate = wxPyBeginAllowThreads();
52563 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52564 wxPyEndAllowThreads(__tstate);
52565 if (PyErr_Occurred()) SWIG_fail;
52566 }
52567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52568 return resultobj;
52569 fail:
52570 return NULL;
52571 }
52572
52573
52574 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52575 PyObject *resultobj = 0;
52576 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52577 void *argp1 = 0 ;
52578 int res1 = 0 ;
52579 PyObject *swig_obj[1] ;
52580
52581 if (!args) SWIG_fail;
52582 swig_obj[0] = args;
52583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52584 if (!SWIG_IsOK(res1)) {
52585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52586 }
52587 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52588 {
52589 PyThreadState* __tstate = wxPyBeginAllowThreads();
52590 delete arg1;
52591
52592 wxPyEndAllowThreads(__tstate);
52593 if (PyErr_Occurred()) SWIG_fail;
52594 }
52595 resultobj = SWIG_Py_Void();
52596 return resultobj;
52597 fail:
52598 return NULL;
52599 }
52600
52601
52602 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52603 PyObject *resultobj = 0;
52604 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52605 wxWindow *arg2 = (wxWindow *) 0 ;
52606 int *arg3 = (int *) 0 ;
52607 bool result;
52608 void *argp1 = 0 ;
52609 int res1 = 0 ;
52610 void *argp2 = 0 ;
52611 int res2 = 0 ;
52612 int temp3 ;
52613 int res3 = SWIG_TMPOBJ ;
52614 PyObject * obj0 = 0 ;
52615 PyObject * obj1 = 0 ;
52616 char * kwnames[] = {
52617 (char *) "self",(char *) "win", NULL
52618 };
52619
52620 arg3 = &temp3;
52621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52623 if (!SWIG_IsOK(res1)) {
52624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52625 }
52626 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52628 if (!SWIG_IsOK(res2)) {
52629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52630 }
52631 arg2 = reinterpret_cast< wxWindow * >(argp2);
52632 {
52633 PyThreadState* __tstate = wxPyBeginAllowThreads();
52634 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52635 wxPyEndAllowThreads(__tstate);
52636 if (PyErr_Occurred()) SWIG_fail;
52637 }
52638 {
52639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52640 }
52641 if (SWIG_IsTmpObj(res3)) {
52642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52643 } else {
52644 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52646 }
52647 return resultobj;
52648 fail:
52649 return NULL;
52650 }
52651
52652
52653 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52654 PyObject *resultobj = 0;
52655 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52656 bool result;
52657 void *argp1 = 0 ;
52658 int res1 = 0 ;
52659 PyObject *swig_obj[1] ;
52660
52661 if (!args) SWIG_fail;
52662 swig_obj[0] = args;
52663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52664 if (!SWIG_IsOK(res1)) {
52665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52666 }
52667 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52668 {
52669 PyThreadState* __tstate = wxPyBeginAllowThreads();
52670 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52671 wxPyEndAllowThreads(__tstate);
52672 if (PyErr_Occurred()) SWIG_fail;
52673 }
52674 {
52675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52676 }
52677 return resultobj;
52678 fail:
52679 return NULL;
52680 }
52681
52682
52683 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52684 PyObject *obj;
52685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52686 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52687 return SWIG_Py_Void();
52688 }
52689
52690 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52691 return SWIG_Python_InitShadowInstance(args);
52692 }
52693
52694 static PyMethodDef SwigMethods[] = {
52695 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52696 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52697 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52698 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52699 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52700 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52701 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52702 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52703 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52705 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52708 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52709 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52710 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52715 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52716 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52717 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52718 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52719 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52720 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52721 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52722 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52723 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52724 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52725 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52727 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52728 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52730 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52731 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52732 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52733 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52734 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52735 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52736 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52737 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52738 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52739 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52741 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52749 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52750 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52751 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52754 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52756 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52757 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52759 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52761 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52763 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52765 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52767 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52769 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52770 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52772 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52774 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52775 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52776 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52777 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52778 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52796 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52797 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52798 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52799 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52800 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52801 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52802 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52803 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52805 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52806 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52807 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52812 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52813 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52814 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52815 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52822 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52829 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52830 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52831 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52832 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52834 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52835 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52836 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52838 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52839 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52840 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52841 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52846 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52847 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52848 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52849 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52850 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52851 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52854 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52855 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52856 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52858 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52859 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52861 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52862 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52863 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52864 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52865 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52866 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52867 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52868 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52869 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52870 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52871 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52876 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52882 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52883 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52884 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52885 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52887 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52890 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52892 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52895 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52896 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52897 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52900 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52901 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52902 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52906 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52907 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52908 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52912 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52917 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52918 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52919 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52920 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52921 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52922 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52923 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52929 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52930 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52932 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52933 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52934 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52940 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52941 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52943 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52944 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52945 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52946 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52947 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52948 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52949 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52950 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52952 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52953 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52954 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52955 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52956 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52957 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52958 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52959 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52961 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52970 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52982 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52983 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52998 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52999 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53000 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53001 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53004 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53006 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53008 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53010 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53012 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53015 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53016 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53017 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53018 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53020 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53037 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53038 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53041 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53044 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53045 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53046 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53047 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53048 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53049 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53050 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53051 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53052 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53053 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53054 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53055 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53056 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53057 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53058 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53059 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53060 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53061 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53062 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53063 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53064 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53065 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53066 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53067 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53068 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53069 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53070 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53071 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53072 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53073 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53074 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53075 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53076 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53077 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53078 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53080 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53081 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53082 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53083 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53086 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53090 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53094 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53095 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53096 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53097 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53099 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53100 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53102 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53104 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53106 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53108 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53109 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53110 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53112 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53113 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53115 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53116 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53117 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53119 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53120 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53121 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53123 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53125 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53126 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53127 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53129 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53131 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53132 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53134 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53135 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53136 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53138 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53139 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53140 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53141 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53142 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53144 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53145 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53148 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53149 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53151 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53152 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53155 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53156 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53158 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53164 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53165 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53166 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53167 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53168 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53169 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53170 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53171 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53172 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53173 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53174 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53175 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53176 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53177 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53178 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53179 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53180 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53181 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53182 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53183 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53184 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53185 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53186 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53187 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53189 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53190 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53191 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53192 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53193 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53194 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53195 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53196 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53197 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53198 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53199 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53200 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53201 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53202 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53203 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53204 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53205 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53206 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53207 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53208 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53209 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53210 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53211 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53212 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53213 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53214 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53215 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53216 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53217 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53218 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53219 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53220 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53222 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53223 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53225 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53226 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53227 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53228 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53229 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53230 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53231 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53232 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53233 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53234 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53235 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53236 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53237 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53238 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53240 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53241 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53242 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53243 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53244 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53245 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53246 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53247 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53248 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53249 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53250 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53251 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53252 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53253 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53254 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53255 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53256 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53257 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53258 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53259 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53260 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53261 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53262 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53263 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53264 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53265 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53266 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53267 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53269 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53270 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53273 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53274 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53275 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53276 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53277 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53278 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53280 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53281 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53284 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53285 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53287 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53288 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53290 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53291 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53293 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53294 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53295 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53297 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53299 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53300 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53302 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53303 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53304 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53306 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53307 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53308 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53310 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53311 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53313 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53314 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53315 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53316 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53317 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53320 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53322 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53324 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53325 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53326 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53329 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53330 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53331 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53333 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53334 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53335 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53337 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53338 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53339 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53340 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53341 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53342 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53344 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53345 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53346 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53347 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53348 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53349 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53350 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53351 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53357 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53359 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53361 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53362 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53363 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53364 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53365 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53366 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53368 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53369 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53370 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53371 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53372 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53373 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53376 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53377 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53378 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53381 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53382 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53383 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53384 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53385 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53387 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53389 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53392 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53394 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53395 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53397 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53398 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53399 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53401 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53402 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53403 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53405 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53407 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53408 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53409 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53411 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53413 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53415 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53416 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53418 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53419 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53421 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53423 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53424 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53427 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53429 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53430 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53431 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53433 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53435 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53436 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53437 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53438 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53440 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53442 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53444 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53446 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53447 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53449 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53450 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53451 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53452 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53453 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53454 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53455 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53456 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53458 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53460 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53462 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53464 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53466 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53468 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53469 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53470 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53471 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53472 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53473 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53479 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53480 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53481 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53482 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53483 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53484 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53485 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53487 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53489 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53490 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53492 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53493 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53494 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53495 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53497 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53498 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53499 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53500 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53502 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53503 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53505 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53506 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53507 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53509 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53511 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53512 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53513 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53514 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53515 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53517 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53518 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53519 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53520 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53522 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53523 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53524 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53525 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53526 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53527 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53528 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53529 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53530 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53531 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53533 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53536 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53537 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53538 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53540 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53542 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53544 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53546 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53547 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53557 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53558 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53562 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53563 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53564 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53565 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53566 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53567 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53568 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53569 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53570 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53571 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53572 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53573 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53574 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53575 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53576 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53578 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53579 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53582 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53583 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53588 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53589 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53592 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53593 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53594 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53595 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53598 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53599 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53600 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53602 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53604 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53605 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53606 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53608 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53610 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53612 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53615 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53616 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53617 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53618 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53619 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53620 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53621 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53627 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53628 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53629 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53630 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53637 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53643 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53644 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53645 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53646 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53647 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53649 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53659 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53660 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53661 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53662 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53665 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53666 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53667 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53668 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53670 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53671 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53675 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53681 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53682 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53683 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53684 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53686 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53687 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53689 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53692 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53694 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53695 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53696 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53705 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53709 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53711 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53722 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53723 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53724 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53725 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53729 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53732 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53734 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53737 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53739 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53740 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53743 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53745 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53746 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53747 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53748 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53749 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53754 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53755 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53756 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53758 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53759 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53760 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53762 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53764 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53765 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53766 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53768 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53769 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53772 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53780 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53787 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53795 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53798 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53799 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53812 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53814 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53816 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53817 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53819 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53821 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53822 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53824 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53825 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53826 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53830 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53849 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53850 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53852 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53854 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53855 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53856 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53858 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53859 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53862 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53863 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53865 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53866 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53868 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53871 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53872 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53874 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53876 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53878 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53879 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53881 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53882 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53885 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53887 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53889 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53891 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53894 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53896 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53897 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53898 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53900 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53901 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53902 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53904 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53907 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53909 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53910 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53914 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53918 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53919 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53921 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53925 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53927 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53929 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53930 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53931 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53932 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53936 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53937 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53938 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53939 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53941 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53942 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53947 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53948 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53949 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53950 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53951 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53953 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53955 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53957 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53958 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53960 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53962 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53965 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53966 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53967 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53969 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53970 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53971 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53985 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53986 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53987 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53988 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53989 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53990 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53996 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53997 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54001 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54002 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54004 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54005 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54007 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54009 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54010 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54012 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54013 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54014 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54020 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54021 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54022 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54023 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54024 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54025 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54032 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54034 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54035 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54036 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54037 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54038 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54039 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54041 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54045 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54046 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54047 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54048 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54049 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54050 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54051 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54053 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54054 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54055 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54061 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54062 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54063 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54065 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54066 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54067 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54073 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54074 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54075 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54076 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54077 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54081 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54082 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54087 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54088 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54090 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54091 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54096 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54098 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54099 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54100 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54101 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54102 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54107 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54108 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54117 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54118 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54119 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54120 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54123 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54125 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54126 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54127 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54128 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54130 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54135 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54136 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54137 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54138 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54139 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54140 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54141 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54142 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54143 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54144 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54145 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54147 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54148 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54149 { NULL, NULL, 0, NULL }
54150 };
54151
54152
54153 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54154
54155 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54156 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54157 }
54158 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54159 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54160 }
54161 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54162 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54163 }
54164 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54165 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54166 }
54167 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54168 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54169 }
54170 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54171 return (void *)((wxSizer *) ((wxGridSizer *) x));
54172 }
54173 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54174 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54175 }
54176 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54177 return (void *)((wxSizer *) ((wxPySizer *) x));
54178 }
54179 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54180 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54181 }
54182 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54183 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54184 }
54185 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54186 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54187 }
54188 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54189 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54190 }
54191 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54192 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54193 }
54194 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54195 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54196 }
54197 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54198 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54199 }
54200 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54201 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54202 }
54203 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54204 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54205 }
54206 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54207 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54208 }
54209 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54210 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54211 }
54212 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54213 return (void *)((wxEvent *) ((wxPyEvent *) x));
54214 }
54215 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54216 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54217 }
54218 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54219 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54220 }
54221 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54222 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54223 }
54224 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54225 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54226 }
54227 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54228 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54229 }
54230 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54231 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54232 }
54233 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54234 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54235 }
54236 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54237 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54238 }
54239 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54240 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54241 }
54242 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54243 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54244 }
54245 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54246 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54247 }
54248 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54249 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54250 }
54251 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54253 }
54254 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54255 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54256 }
54257 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54258 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54259 }
54260 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54261 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54262 }
54263 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54264 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54265 }
54266 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54267 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54268 }
54269 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54270 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54271 }
54272 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54273 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54274 }
54275 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54276 return (void *)((wxEvent *) ((wxShowEvent *) x));
54277 }
54278 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54279 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54280 }
54281 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54282 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54283 }
54284 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54285 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54286 }
54287 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54288 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54289 }
54290 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54291 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54292 }
54293 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54294 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54295 }
54296 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54297 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54298 }
54299 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54300 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54301 }
54302 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54303 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54304 }
54305 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54306 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54307 }
54308 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54309 return (void *)((wxControl *) ((wxControlWithItems *) x));
54310 }
54311 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54312 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54313 }
54314 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54315 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54316 }
54317 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54318 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54319 }
54320 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54321 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54322 }
54323 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54324 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54325 }
54326 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54327 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54328 }
54329 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54330 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54331 }
54332 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54333 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54334 }
54335 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54336 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54337 }
54338 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54339 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54340 }
54341 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54342 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54343 }
54344 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54345 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54346 }
54347 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54348 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54349 }
54350 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54351 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54352 }
54353 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54354 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54355 }
54356 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54357 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54358 }
54359 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54360 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54361 }
54362 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54363 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54364 }
54365 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54366 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54367 }
54368 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54369 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54370 }
54371 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54372 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54373 }
54374 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54375 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54376 }
54377 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54378 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54379 }
54380 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54381 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54382 }
54383 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54384 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54385 }
54386 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54387 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54388 }
54389 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54390 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54391 }
54392 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54393 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54394 }
54395 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54396 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54397 }
54398 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54399 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54400 }
54401 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54402 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54403 }
54404 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54405 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54406 }
54407 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54408 return (void *)((wxObject *) ((wxSizerItem *) x));
54409 }
54410 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54411 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54412 }
54413 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54414 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54415 }
54416 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54417 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54418 }
54419 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54420 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54421 }
54422 static void *_p_wxSizerTo_p_wxObject(void *x) {
54423 return (void *)((wxObject *) ((wxSizer *) x));
54424 }
54425 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54426 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54427 }
54428 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54429 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54430 }
54431 static void *_p_wxEventTo_p_wxObject(void *x) {
54432 return (void *)((wxObject *) ((wxEvent *) x));
54433 }
54434 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54435 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54436 }
54437 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54438 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54439 }
54440 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54441 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54442 }
54443 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54444 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54445 }
54446 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54447 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54448 }
54449 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54450 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54451 }
54452 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54453 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54454 }
54455 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54456 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54457 }
54458 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54459 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54460 }
54461 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54462 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54463 }
54464 static void *_p_wxControlTo_p_wxObject(void *x) {
54465 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54466 }
54467 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54468 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54469 }
54470 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54471 return (void *)((wxObject *) ((wxFSFile *) x));
54472 }
54473 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54474 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54475 }
54476 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54477 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54478 }
54479 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54480 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54481 }
54482 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54483 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54484 }
54485 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54486 return (void *)((wxObject *) ((wxMenuItem *) x));
54487 }
54488 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54489 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54490 }
54491 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54492 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54493 }
54494 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54496 }
54497 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54498 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54499 }
54500 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54501 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54502 }
54503 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54504 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54505 }
54506 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54507 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54508 }
54509 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54510 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54511 }
54512 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54513 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54514 }
54515 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54516 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54517 }
54518 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54519 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54520 }
54521 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54522 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54523 }
54524 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54525 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54526 }
54527 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54528 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54529 }
54530 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54531 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54532 }
54533 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54534 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54535 }
54536 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54537 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54538 }
54539 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54540 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54541 }
54542 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54543 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54544 }
54545 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54546 return (void *)((wxObject *) ((wxImageHandler *) x));
54547 }
54548 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54549 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54550 }
54551 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54552 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54553 }
54554 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54555 return (void *)((wxObject *) ((wxEvtHandler *) x));
54556 }
54557 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54558 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54559 }
54560 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54561 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54562 }
54563 static void *_p_wxImageTo_p_wxObject(void *x) {
54564 return (void *)((wxObject *) ((wxImage *) x));
54565 }
54566 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54567 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54568 }
54569 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54570 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54571 }
54572 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54573 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54574 }
54575 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54576 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54577 }
54578 static void *_p_wxWindowTo_p_wxObject(void *x) {
54579 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54580 }
54581 static void *_p_wxMenuTo_p_wxObject(void *x) {
54582 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54583 }
54584 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54585 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54586 }
54587 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54588 return (void *)((wxObject *) ((wxFileSystem *) x));
54589 }
54590 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54591 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54592 }
54593 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54594 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54595 }
54596 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54597 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54598 }
54599 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54600 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54601 }
54602 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54603 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54604 }
54605 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54606 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54607 }
54608 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54609 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54610 }
54611 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54612 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54613 }
54614 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54615 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54616 }
54617 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54618 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54619 }
54620 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54621 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54622 }
54623 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54624 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54625 }
54626 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54627 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54628 }
54629 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54630 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54631 }
54632 static void *_p_wxControlTo_p_wxWindow(void *x) {
54633 return (void *)((wxWindow *) ((wxControl *) x));
54634 }
54635 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54636 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54637 }
54638 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54639 return (void *)((wxWindow *) ((wxMenuBar *) x));
54640 }
54641 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54642 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54643 }
54644 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54645 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54646 }
54647 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54648 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54649 }
54650 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54651 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54652 }
54653 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54654 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54655 }
54656 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54657 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54658 }
54659 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54660 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54661 }
54662 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54663 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54664 }
54665 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54666 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54667 }
54668 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54669 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54670 }
54671 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54672 return (void *)((wxValidator *) ((wxPyValidator *) x));
54673 }
54674 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54675 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54676 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};
54677 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54678 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54679 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54680 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54681 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54682 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54683 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54684 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54685 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54686 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54687 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54688 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54689 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54690 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54691 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54692 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54693 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54694 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54695 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54696 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54697 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54698 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54699 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54700 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54701 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54702 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54703 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54704 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54705 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54706 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54707 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54708 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54709 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54710 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54711 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54712 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54713 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54714 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54715 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54716 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54717 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54718 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54719 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54720 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54721 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54722 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54723 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54724 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54725 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54726 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54727 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54728 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54729 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54730 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54731 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54732 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54733 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54734 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54735 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54736 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54737 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54739 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54740 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54777 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54778 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54779 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54780 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54781 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54782 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54783 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54784 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54785 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54786 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54787 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54788 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54789 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54790 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54793 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54805
54806 static swig_type_info *swig_type_initial[] = {
54807 &_swigt__p_buffer,
54808 &_swigt__p_char,
54809 &_swigt__p_form_ops_t,
54810 &_swigt__p_int,
54811 &_swigt__p_long,
54812 &_swigt__p_unsigned_char,
54813 &_swigt__p_unsigned_int,
54814 &_swigt__p_unsigned_long,
54815 &_swigt__p_wxANIHandler,
54816 &_swigt__p_wxAcceleratorEntry,
54817 &_swigt__p_wxAcceleratorTable,
54818 &_swigt__p_wxActivateEvent,
54819 &_swigt__p_wxAppTraits,
54820 &_swigt__p_wxArrayString,
54821 &_swigt__p_wxBMPHandler,
54822 &_swigt__p_wxBitmap,
54823 &_swigt__p_wxBoxSizer,
54824 &_swigt__p_wxButton,
54825 &_swigt__p_wxCURHandler,
54826 &_swigt__p_wxCaret,
54827 &_swigt__p_wxChildFocusEvent,
54828 &_swigt__p_wxClipboardTextEvent,
54829 &_swigt__p_wxCloseEvent,
54830 &_swigt__p_wxColour,
54831 &_swigt__p_wxCommandEvent,
54832 &_swigt__p_wxContextMenuEvent,
54833 &_swigt__p_wxControl,
54834 &_swigt__p_wxControlWithItems,
54835 &_swigt__p_wxCursor,
54836 &_swigt__p_wxDC,
54837 &_swigt__p_wxDateEvent,
54838 &_swigt__p_wxDateTime,
54839 &_swigt__p_wxDisplayChangedEvent,
54840 &_swigt__p_wxDropFilesEvent,
54841 &_swigt__p_wxDuplexMode,
54842 &_swigt__p_wxEraseEvent,
54843 &_swigt__p_wxEvent,
54844 &_swigt__p_wxEventLoop,
54845 &_swigt__p_wxEventLoopActivator,
54846 &_swigt__p_wxEvtHandler,
54847 &_swigt__p_wxFSFile,
54848 &_swigt__p_wxFileSystem,
54849 &_swigt__p_wxFileSystemHandler,
54850 &_swigt__p_wxFlexGridSizer,
54851 &_swigt__p_wxFocusEvent,
54852 &_swigt__p_wxFont,
54853 &_swigt__p_wxFrame,
54854 &_swigt__p_wxGBPosition,
54855 &_swigt__p_wxGBSizerItem,
54856 &_swigt__p_wxGBSpan,
54857 &_swigt__p_wxGIFHandler,
54858 &_swigt__p_wxGridBagSizer,
54859 &_swigt__p_wxGridSizer,
54860 &_swigt__p_wxHelpEvent__Origin,
54861 &_swigt__p_wxICOHandler,
54862 &_swigt__p_wxIconizeEvent,
54863 &_swigt__p_wxIdleEvent,
54864 &_swigt__p_wxImage,
54865 &_swigt__p_wxImageHandler,
54866 &_swigt__p_wxImageHistogram,
54867 &_swigt__p_wxImage_HSVValue,
54868 &_swigt__p_wxImage_RGBValue,
54869 &_swigt__p_wxIndividualLayoutConstraint,
54870 &_swigt__p_wxInitDialogEvent,
54871 &_swigt__p_wxInputStream,
54872 &_swigt__p_wxInternetFSHandler,
54873 &_swigt__p_wxItemContainer,
54874 &_swigt__p_wxJPEGHandler,
54875 &_swigt__p_wxKeyEvent,
54876 &_swigt__p_wxLayoutConstraints,
54877 &_swigt__p_wxMaximizeEvent,
54878 &_swigt__p_wxMemoryFSHandler,
54879 &_swigt__p_wxMenu,
54880 &_swigt__p_wxMenuBar,
54881 &_swigt__p_wxMenuBarBase,
54882 &_swigt__p_wxMenuEvent,
54883 &_swigt__p_wxMenuItem,
54884 &_swigt__p_wxMouseCaptureChangedEvent,
54885 &_swigt__p_wxMouseEvent,
54886 &_swigt__p_wxMoveEvent,
54887 &_swigt__p_wxNavigationKeyEvent,
54888 &_swigt__p_wxNcPaintEvent,
54889 &_swigt__p_wxNotifyEvent,
54890 &_swigt__p_wxObject,
54891 &_swigt__p_wxOutputStream,
54892 &_swigt__p_wxPCXHandler,
54893 &_swigt__p_wxPNGHandler,
54894 &_swigt__p_wxPNMHandler,
54895 &_swigt__p_wxPaintEvent,
54896 &_swigt__p_wxPaletteChangedEvent,
54897 &_swigt__p_wxPaperSize,
54898 &_swigt__p_wxPoint,
54899 &_swigt__p_wxPoint2D,
54900 &_swigt__p_wxPropagateOnce,
54901 &_swigt__p_wxPropagationDisabler,
54902 &_swigt__p_wxPyApp,
54903 &_swigt__p_wxPyCommandEvent,
54904 &_swigt__p_wxPyDropTarget,
54905 &_swigt__p_wxPyEvent,
54906 &_swigt__p_wxPyFileSystemHandler,
54907 &_swigt__p_wxPyImageHandler,
54908 &_swigt__p_wxPyInputStream,
54909 &_swigt__p_wxPySizer,
54910 &_swigt__p_wxPyValidator,
54911 &_swigt__p_wxQuantize,
54912 &_swigt__p_wxQueryNewPaletteEvent,
54913 &_swigt__p_wxRealPoint,
54914 &_swigt__p_wxRect,
54915 &_swigt__p_wxRegion,
54916 &_swigt__p_wxScrollEvent,
54917 &_swigt__p_wxScrollWinEvent,
54918 &_swigt__p_wxSetCursorEvent,
54919 &_swigt__p_wxShowEvent,
54920 &_swigt__p_wxSize,
54921 &_swigt__p_wxSizeEvent,
54922 &_swigt__p_wxSizer,
54923 &_swigt__p_wxSizerItem,
54924 &_swigt__p_wxStaticBox,
54925 &_swigt__p_wxStaticBoxSizer,
54926 &_swigt__p_wxStdDialogButtonSizer,
54927 &_swigt__p_wxSysColourChangedEvent,
54928 &_swigt__p_wxTIFFHandler,
54929 &_swigt__p_wxToolTip,
54930 &_swigt__p_wxUpdateUIEvent,
54931 &_swigt__p_wxValidator,
54932 &_swigt__p_wxVisualAttributes,
54933 &_swigt__p_wxWindow,
54934 &_swigt__p_wxWindowCreateEvent,
54935 &_swigt__p_wxWindowDestroyEvent,
54936 &_swigt__p_wxXPMHandler,
54937 &_swigt__p_wxZipFSHandler,
54938 };
54939
54940 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54941 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54942 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54943 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54944 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54945 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54946 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54947 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54948 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54949 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54950 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54951 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54952 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54953 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54954 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}};
54955 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54956 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}};
54957 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54958 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}};
54959 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54960 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54961 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54962 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54963 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54964 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}};
54965 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54966 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}};
54967 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54968 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54969 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54970 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54971 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54972 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54973 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54974 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54975 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54976 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}};
54977 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54978 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54979 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}};
54980 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54981 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54982 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}};
54983 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}};
54984 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54985 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54986 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54987 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54988 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54989 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54990 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54991 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54992 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}};
54993 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
54994 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}};
54995 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54996 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54997 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54998 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}};
54999 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55000 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55001 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55002 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55003 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55006 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}};
55007 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55008 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55009 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55010 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55011 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55012 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55013 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55014 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55015 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55016 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55017 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55018 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55019 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55020 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55021 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55022 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55023 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}};
55024 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55025 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55026 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55027 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55028 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55029 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55030 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55031 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55032 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55034 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55035 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55036 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55037 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55038 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55039 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55042 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55043 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55044 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55045 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55046 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55047 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55048 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55049 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55050 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55051 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55052 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55053 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55054 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55055 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}};
55056 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}};
55057 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55058 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55061 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55062 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55064 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}};
55065 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55066 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}};
55067 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55071
55072 static swig_cast_info *swig_cast_initial[] = {
55073 _swigc__p_buffer,
55074 _swigc__p_char,
55075 _swigc__p_form_ops_t,
55076 _swigc__p_int,
55077 _swigc__p_long,
55078 _swigc__p_unsigned_char,
55079 _swigc__p_unsigned_int,
55080 _swigc__p_unsigned_long,
55081 _swigc__p_wxANIHandler,
55082 _swigc__p_wxAcceleratorEntry,
55083 _swigc__p_wxAcceleratorTable,
55084 _swigc__p_wxActivateEvent,
55085 _swigc__p_wxAppTraits,
55086 _swigc__p_wxArrayString,
55087 _swigc__p_wxBMPHandler,
55088 _swigc__p_wxBitmap,
55089 _swigc__p_wxBoxSizer,
55090 _swigc__p_wxButton,
55091 _swigc__p_wxCURHandler,
55092 _swigc__p_wxCaret,
55093 _swigc__p_wxChildFocusEvent,
55094 _swigc__p_wxClipboardTextEvent,
55095 _swigc__p_wxCloseEvent,
55096 _swigc__p_wxColour,
55097 _swigc__p_wxCommandEvent,
55098 _swigc__p_wxContextMenuEvent,
55099 _swigc__p_wxControl,
55100 _swigc__p_wxControlWithItems,
55101 _swigc__p_wxCursor,
55102 _swigc__p_wxDC,
55103 _swigc__p_wxDateEvent,
55104 _swigc__p_wxDateTime,
55105 _swigc__p_wxDisplayChangedEvent,
55106 _swigc__p_wxDropFilesEvent,
55107 _swigc__p_wxDuplexMode,
55108 _swigc__p_wxEraseEvent,
55109 _swigc__p_wxEvent,
55110 _swigc__p_wxEventLoop,
55111 _swigc__p_wxEventLoopActivator,
55112 _swigc__p_wxEvtHandler,
55113 _swigc__p_wxFSFile,
55114 _swigc__p_wxFileSystem,
55115 _swigc__p_wxFileSystemHandler,
55116 _swigc__p_wxFlexGridSizer,
55117 _swigc__p_wxFocusEvent,
55118 _swigc__p_wxFont,
55119 _swigc__p_wxFrame,
55120 _swigc__p_wxGBPosition,
55121 _swigc__p_wxGBSizerItem,
55122 _swigc__p_wxGBSpan,
55123 _swigc__p_wxGIFHandler,
55124 _swigc__p_wxGridBagSizer,
55125 _swigc__p_wxGridSizer,
55126 _swigc__p_wxHelpEvent__Origin,
55127 _swigc__p_wxICOHandler,
55128 _swigc__p_wxIconizeEvent,
55129 _swigc__p_wxIdleEvent,
55130 _swigc__p_wxImage,
55131 _swigc__p_wxImageHandler,
55132 _swigc__p_wxImageHistogram,
55133 _swigc__p_wxImage_HSVValue,
55134 _swigc__p_wxImage_RGBValue,
55135 _swigc__p_wxIndividualLayoutConstraint,
55136 _swigc__p_wxInitDialogEvent,
55137 _swigc__p_wxInputStream,
55138 _swigc__p_wxInternetFSHandler,
55139 _swigc__p_wxItemContainer,
55140 _swigc__p_wxJPEGHandler,
55141 _swigc__p_wxKeyEvent,
55142 _swigc__p_wxLayoutConstraints,
55143 _swigc__p_wxMaximizeEvent,
55144 _swigc__p_wxMemoryFSHandler,
55145 _swigc__p_wxMenu,
55146 _swigc__p_wxMenuBar,
55147 _swigc__p_wxMenuBarBase,
55148 _swigc__p_wxMenuEvent,
55149 _swigc__p_wxMenuItem,
55150 _swigc__p_wxMouseCaptureChangedEvent,
55151 _swigc__p_wxMouseEvent,
55152 _swigc__p_wxMoveEvent,
55153 _swigc__p_wxNavigationKeyEvent,
55154 _swigc__p_wxNcPaintEvent,
55155 _swigc__p_wxNotifyEvent,
55156 _swigc__p_wxObject,
55157 _swigc__p_wxOutputStream,
55158 _swigc__p_wxPCXHandler,
55159 _swigc__p_wxPNGHandler,
55160 _swigc__p_wxPNMHandler,
55161 _swigc__p_wxPaintEvent,
55162 _swigc__p_wxPaletteChangedEvent,
55163 _swigc__p_wxPaperSize,
55164 _swigc__p_wxPoint,
55165 _swigc__p_wxPoint2D,
55166 _swigc__p_wxPropagateOnce,
55167 _swigc__p_wxPropagationDisabler,
55168 _swigc__p_wxPyApp,
55169 _swigc__p_wxPyCommandEvent,
55170 _swigc__p_wxPyDropTarget,
55171 _swigc__p_wxPyEvent,
55172 _swigc__p_wxPyFileSystemHandler,
55173 _swigc__p_wxPyImageHandler,
55174 _swigc__p_wxPyInputStream,
55175 _swigc__p_wxPySizer,
55176 _swigc__p_wxPyValidator,
55177 _swigc__p_wxQuantize,
55178 _swigc__p_wxQueryNewPaletteEvent,
55179 _swigc__p_wxRealPoint,
55180 _swigc__p_wxRect,
55181 _swigc__p_wxRegion,
55182 _swigc__p_wxScrollEvent,
55183 _swigc__p_wxScrollWinEvent,
55184 _swigc__p_wxSetCursorEvent,
55185 _swigc__p_wxShowEvent,
55186 _swigc__p_wxSize,
55187 _swigc__p_wxSizeEvent,
55188 _swigc__p_wxSizer,
55189 _swigc__p_wxSizerItem,
55190 _swigc__p_wxStaticBox,
55191 _swigc__p_wxStaticBoxSizer,
55192 _swigc__p_wxStdDialogButtonSizer,
55193 _swigc__p_wxSysColourChangedEvent,
55194 _swigc__p_wxTIFFHandler,
55195 _swigc__p_wxToolTip,
55196 _swigc__p_wxUpdateUIEvent,
55197 _swigc__p_wxValidator,
55198 _swigc__p_wxVisualAttributes,
55199 _swigc__p_wxWindow,
55200 _swigc__p_wxWindowCreateEvent,
55201 _swigc__p_wxWindowDestroyEvent,
55202 _swigc__p_wxXPMHandler,
55203 _swigc__p_wxZipFSHandler,
55204 };
55205
55206
55207 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55208
55209 static swig_const_info swig_const_table[] = {
55210 {0, 0, 0, 0.0, 0, 0}};
55211
55212 #ifdef __cplusplus
55213 }
55214 #endif
55215 /* -----------------------------------------------------------------------------
55216 * Type initialization:
55217 * This problem is tough by the requirement that no dynamic
55218 * memory is used. Also, since swig_type_info structures store pointers to
55219 * swig_cast_info structures and swig_cast_info structures store pointers back
55220 * to swig_type_info structures, we need some lookup code at initialization.
55221 * The idea is that swig generates all the structures that are needed.
55222 * The runtime then collects these partially filled structures.
55223 * The SWIG_InitializeModule function takes these initial arrays out of
55224 * swig_module, and does all the lookup, filling in the swig_module.types
55225 * array with the correct data and linking the correct swig_cast_info
55226 * structures together.
55227 *
55228 * The generated swig_type_info structures are assigned staticly to an initial
55229 * array. We just loop though that array, and handle each type individually.
55230 * First we lookup if this type has been already loaded, and if so, use the
55231 * loaded structure instead of the generated one. Then we have to fill in the
55232 * cast linked list. The cast data is initially stored in something like a
55233 * two-dimensional array. Each row corresponds to a type (there are the same
55234 * number of rows as there are in the swig_type_initial array). Each entry in
55235 * a column is one of the swig_cast_info structures for that type.
55236 * The cast_initial array is actually an array of arrays, because each row has
55237 * a variable number of columns. So to actually build the cast linked list,
55238 * we find the array of casts associated with the type, and loop through it
55239 * adding the casts to the list. The one last trick we need to do is making
55240 * sure the type pointer in the swig_cast_info struct is correct.
55241 *
55242 * First off, we lookup the cast->type name to see if it is already loaded.
55243 * There are three cases to handle:
55244 * 1) If the cast->type has already been loaded AND the type we are adding
55245 * casting info to has not been loaded (it is in this module), THEN we
55246 * replace the cast->type pointer with the type pointer that has already
55247 * been loaded.
55248 * 2) If BOTH types (the one we are adding casting info to, and the
55249 * cast->type) are loaded, THEN the cast info has already been loaded by
55250 * the previous module so we just ignore it.
55251 * 3) Finally, if cast->type has not already been loaded, then we add that
55252 * swig_cast_info to the linked list (because the cast->type) pointer will
55253 * be correct.
55254 * ----------------------------------------------------------------------------- */
55255
55256 #ifdef __cplusplus
55257 extern "C" {
55258 #if 0
55259 } /* c-mode */
55260 #endif
55261 #endif
55262
55263 #if 0
55264 #define SWIGRUNTIME_DEBUG
55265 #endif
55266
55267 SWIGRUNTIME void
55268 SWIG_InitializeModule(void *clientdata) {
55269 size_t i;
55270 swig_module_info *module_head;
55271 static int init_run = 0;
55272
55273 clientdata = clientdata;
55274
55275 if (init_run) return;
55276 init_run = 1;
55277
55278 /* Initialize the swig_module */
55279 swig_module.type_initial = swig_type_initial;
55280 swig_module.cast_initial = swig_cast_initial;
55281
55282 /* Try and load any already created modules */
55283 module_head = SWIG_GetModule(clientdata);
55284 if (module_head) {
55285 swig_module.next = module_head->next;
55286 module_head->next = &swig_module;
55287 } else {
55288 /* This is the first module loaded */
55289 swig_module.next = &swig_module;
55290 SWIG_SetModule(clientdata, &swig_module);
55291 }
55292
55293 /* Now work on filling in swig_module.types */
55294 #ifdef SWIGRUNTIME_DEBUG
55295 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55296 #endif
55297 for (i = 0; i < swig_module.size; ++i) {
55298 swig_type_info *type = 0;
55299 swig_type_info *ret;
55300 swig_cast_info *cast;
55301
55302 #ifdef SWIGRUNTIME_DEBUG
55303 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55304 #endif
55305
55306 /* if there is another module already loaded */
55307 if (swig_module.next != &swig_module) {
55308 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55309 }
55310 if (type) {
55311 /* Overwrite clientdata field */
55312 #ifdef SWIGRUNTIME_DEBUG
55313 printf("SWIG_InitializeModule: found type %s\n", type->name);
55314 #endif
55315 if (swig_module.type_initial[i]->clientdata) {
55316 type->clientdata = swig_module.type_initial[i]->clientdata;
55317 #ifdef SWIGRUNTIME_DEBUG
55318 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55319 #endif
55320 }
55321 } else {
55322 type = swig_module.type_initial[i];
55323 }
55324
55325 /* Insert casting types */
55326 cast = swig_module.cast_initial[i];
55327 while (cast->type) {
55328 /* Don't need to add information already in the list */
55329 ret = 0;
55330 #ifdef SWIGRUNTIME_DEBUG
55331 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55332 #endif
55333 if (swig_module.next != &swig_module) {
55334 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55335 #ifdef SWIGRUNTIME_DEBUG
55336 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55337 #endif
55338 }
55339 if (ret) {
55340 if (type == swig_module.type_initial[i]) {
55341 #ifdef SWIGRUNTIME_DEBUG
55342 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55343 #endif
55344 cast->type = ret;
55345 ret = 0;
55346 } else {
55347 /* Check for casting already in the list */
55348 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55349 #ifdef SWIGRUNTIME_DEBUG
55350 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55351 #endif
55352 if (!ocast) ret = 0;
55353 }
55354 }
55355
55356 if (!ret) {
55357 #ifdef SWIGRUNTIME_DEBUG
55358 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55359 #endif
55360 if (type->cast) {
55361 type->cast->prev = cast;
55362 cast->next = type->cast;
55363 }
55364 type->cast = cast;
55365 }
55366 cast++;
55367 }
55368 /* Set entry in modules->types array equal to the type */
55369 swig_module.types[i] = type;
55370 }
55371 swig_module.types[i] = 0;
55372
55373 #ifdef SWIGRUNTIME_DEBUG
55374 printf("**** SWIG_InitializeModule: Cast List ******\n");
55375 for (i = 0; i < swig_module.size; ++i) {
55376 int j = 0;
55377 swig_cast_info *cast = swig_module.cast_initial[i];
55378 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55379 while (cast->type) {
55380 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55381 cast++;
55382 ++j;
55383 }
55384 printf("---- Total casts: %d\n",j);
55385 }
55386 printf("**** SWIG_InitializeModule: Cast List ******\n");
55387 #endif
55388 }
55389
55390 /* This function will propagate the clientdata field of type to
55391 * any new swig_type_info structures that have been added into the list
55392 * of equivalent types. It is like calling
55393 * SWIG_TypeClientData(type, clientdata) a second time.
55394 */
55395 SWIGRUNTIME void
55396 SWIG_PropagateClientData(void) {
55397 size_t i;
55398 swig_cast_info *equiv;
55399 static int init_run = 0;
55400
55401 if (init_run) return;
55402 init_run = 1;
55403
55404 for (i = 0; i < swig_module.size; i++) {
55405 if (swig_module.types[i]->clientdata) {
55406 equiv = swig_module.types[i]->cast;
55407 while (equiv) {
55408 if (!equiv->converter) {
55409 if (equiv->type && !equiv->type->clientdata)
55410 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55411 }
55412 equiv = equiv->next;
55413 }
55414 }
55415 }
55416 }
55417
55418 #ifdef __cplusplus
55419 #if 0
55420 {
55421 /* c-mode */
55422 #endif
55423 }
55424 #endif
55425
55426
55427
55428 #ifdef __cplusplus
55429 extern "C" {
55430 #endif
55431
55432 /* Python-specific SWIG API */
55433 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55434 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55435 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55436
55437 /* -----------------------------------------------------------------------------
55438 * global variable support code.
55439 * ----------------------------------------------------------------------------- */
55440
55441 typedef struct swig_globalvar {
55442 char *name; /* Name of global variable */
55443 PyObject *(*get_attr)(void); /* Return the current value */
55444 int (*set_attr)(PyObject *); /* Set the value */
55445 struct swig_globalvar *next;
55446 } swig_globalvar;
55447
55448 typedef struct swig_varlinkobject {
55449 PyObject_HEAD
55450 swig_globalvar *vars;
55451 } swig_varlinkobject;
55452
55453 SWIGINTERN PyObject *
55454 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55455 return PyString_FromString("<Swig global variables>");
55456 }
55457
55458 SWIGINTERN PyObject *
55459 swig_varlink_str(swig_varlinkobject *v) {
55460 PyObject *str = PyString_FromString("(");
55461 swig_globalvar *var;
55462 for (var = v->vars; var; var=var->next) {
55463 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55464 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55465 }
55466 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55467 return str;
55468 }
55469
55470 SWIGINTERN int
55471 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55472 PyObject *str = swig_varlink_str(v);
55473 fprintf(fp,"Swig global variables ");
55474 fprintf(fp,"%s\n", PyString_AsString(str));
55475 Py_DECREF(str);
55476 return 0;
55477 }
55478
55479 SWIGINTERN void
55480 swig_varlink_dealloc(swig_varlinkobject *v) {
55481 swig_globalvar *var = v->vars;
55482 while (var) {
55483 swig_globalvar *n = var->next;
55484 free(var->name);
55485 free(var);
55486 var = n;
55487 }
55488 }
55489
55490 SWIGINTERN PyObject *
55491 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55492 PyObject *res = NULL;
55493 swig_globalvar *var = v->vars;
55494 while (var) {
55495 if (strcmp(var->name,n) == 0) {
55496 res = (*var->get_attr)();
55497 break;
55498 }
55499 var = var->next;
55500 }
55501 if (res == NULL && !PyErr_Occurred()) {
55502 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55503 }
55504 return res;
55505 }
55506
55507 SWIGINTERN int
55508 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55509 int res = 1;
55510 swig_globalvar *var = v->vars;
55511 while (var) {
55512 if (strcmp(var->name,n) == 0) {
55513 res = (*var->set_attr)(p);
55514 break;
55515 }
55516 var = var->next;
55517 }
55518 if (res == 1 && !PyErr_Occurred()) {
55519 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55520 }
55521 return res;
55522 }
55523
55524 SWIGINTERN PyTypeObject*
55525 swig_varlink_type(void) {
55526 static char varlink__doc__[] = "Swig var link object";
55527 static PyTypeObject varlink_type;
55528 static int type_init = 0;
55529 if (!type_init) {
55530 const PyTypeObject tmp
55531 = {
55532 PyObject_HEAD_INIT(NULL)
55533 0, /* Number of items in variable part (ob_size) */
55534 (char *)"swigvarlink", /* Type name (tp_name) */
55535 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55536 0, /* Itemsize (tp_itemsize) */
55537 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55538 (printfunc) swig_varlink_print, /* Print (tp_print) */
55539 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55540 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55541 0, /* tp_compare */
55542 (reprfunc) swig_varlink_repr, /* tp_repr */
55543 0, /* tp_as_number */
55544 0, /* tp_as_sequence */
55545 0, /* tp_as_mapping */
55546 0, /* tp_hash */
55547 0, /* tp_call */
55548 (reprfunc)swig_varlink_str, /* tp_str */
55549 0, /* tp_getattro */
55550 0, /* tp_setattro */
55551 0, /* tp_as_buffer */
55552 0, /* tp_flags */
55553 varlink__doc__, /* tp_doc */
55554 0, /* tp_traverse */
55555 0, /* tp_clear */
55556 0, /* tp_richcompare */
55557 0, /* tp_weaklistoffset */
55558 #if PY_VERSION_HEX >= 0x02020000
55559 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55560 #endif
55561 #if PY_VERSION_HEX >= 0x02030000
55562 0, /* tp_del */
55563 #endif
55564 #ifdef COUNT_ALLOCS
55565 0,0,0,0 /* tp_alloc -> tp_next */
55566 #endif
55567 };
55568 varlink_type = tmp;
55569 varlink_type.ob_type = &PyType_Type;
55570 type_init = 1;
55571 }
55572 return &varlink_type;
55573 }
55574
55575 /* Create a variable linking object for use later */
55576 SWIGINTERN PyObject *
55577 SWIG_Python_newvarlink(void) {
55578 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55579 if (result) {
55580 result->vars = 0;
55581 }
55582 return ((PyObject*) result);
55583 }
55584
55585 SWIGINTERN void
55586 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55587 swig_varlinkobject *v = (swig_varlinkobject *) p;
55588 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55589 if (gv) {
55590 size_t size = strlen(name)+1;
55591 gv->name = (char *)malloc(size);
55592 if (gv->name) {
55593 strncpy(gv->name,name,size);
55594 gv->get_attr = get_attr;
55595 gv->set_attr = set_attr;
55596 gv->next = v->vars;
55597 }
55598 }
55599 v->vars = gv;
55600 }
55601
55602 SWIGINTERN PyObject *
55603 SWIG_globals() {
55604 static PyObject *_SWIG_globals = 0;
55605 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55606 return _SWIG_globals;
55607 }
55608
55609 /* -----------------------------------------------------------------------------
55610 * constants/methods manipulation
55611 * ----------------------------------------------------------------------------- */
55612
55613 /* Install Constants */
55614 SWIGINTERN void
55615 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55616 PyObject *obj = 0;
55617 size_t i;
55618 for (i = 0; constants[i].type; ++i) {
55619 switch(constants[i].type) {
55620 case SWIG_PY_POINTER:
55621 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55622 break;
55623 case SWIG_PY_BINARY:
55624 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55625 break;
55626 default:
55627 obj = 0;
55628 break;
55629 }
55630 if (obj) {
55631 PyDict_SetItemString(d, constants[i].name, obj);
55632 Py_DECREF(obj);
55633 }
55634 }
55635 }
55636
55637 /* -----------------------------------------------------------------------------*/
55638 /* Fix SwigMethods to carry the callback ptrs when needed */
55639 /* -----------------------------------------------------------------------------*/
55640
55641 SWIGINTERN void
55642 SWIG_Python_FixMethods(PyMethodDef *methods,
55643 swig_const_info *const_table,
55644 swig_type_info **types,
55645 swig_type_info **types_initial) {
55646 size_t i;
55647 for (i = 0; methods[i].ml_name; ++i) {
55648 char *c = methods[i].ml_doc;
55649 if (c && (c = strstr(c, "swig_ptr: "))) {
55650 int j;
55651 swig_const_info *ci = 0;
55652 char *name = c + 10;
55653 for (j = 0; const_table[j].type; ++j) {
55654 if (strncmp(const_table[j].name, name,
55655 strlen(const_table[j].name)) == 0) {
55656 ci = &(const_table[j]);
55657 break;
55658 }
55659 }
55660 if (ci) {
55661 size_t shift = (ci->ptype) - types;
55662 swig_type_info *ty = types_initial[shift];
55663 size_t ldoc = (c - methods[i].ml_doc);
55664 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55665 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55666 if (ndoc) {
55667 char *buff = ndoc;
55668 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55669 if (ptr) {
55670 strncpy(buff, methods[i].ml_doc, ldoc);
55671 buff += ldoc;
55672 strncpy(buff, "swig_ptr: ", 10);
55673 buff += 10;
55674 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55675 methods[i].ml_doc = ndoc;
55676 }
55677 }
55678 }
55679 }
55680 }
55681 }
55682
55683 #ifdef __cplusplus
55684 }
55685 #endif
55686
55687 /* -----------------------------------------------------------------------------*
55688 * Partial Init method
55689 * -----------------------------------------------------------------------------*/
55690
55691 #ifdef __cplusplus
55692 extern "C"
55693 #endif
55694 SWIGEXPORT void SWIG_init(void) {
55695 PyObject *m, *d;
55696
55697 /* Fix SwigMethods to carry the callback ptrs when needed */
55698 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55699
55700 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55701 d = PyModule_GetDict(m);
55702
55703 SWIG_InitializeModule(0);
55704 SWIG_InstallConstants(d,swig_const_table);
55705
55706
55707
55708 #ifndef wxPyUSE_EXPORT
55709 // Make our API structure a CObject so other modules can import it
55710 // from this module.
55711 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55712 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55713 Py_XDECREF(cobj);
55714 #endif
55715
55716 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55717 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55718 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55719 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55720 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55721 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55722 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55723 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55724 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55725 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55726 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55727 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55728 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55729 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55730 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55731 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55732 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55733 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55734 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55735 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55736 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55737 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55738 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55739 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55740 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55741 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55742 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55743 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55744 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55745 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55746 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55747 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55748 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55749 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55750 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55751 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55752 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55753 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55754 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55755 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55756 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55757 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55758 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55759 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55760 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55761 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55762 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55763 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55764 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55765 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55766 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55767 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55768 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55769 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55770 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55771 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55772 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55773 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55774 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55775 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55776 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55777 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55778 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55779 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55780 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55781 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55782 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55783 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55784 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55785 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55786 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55787 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55788 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55789 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55790 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55791 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55792 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55793 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55794 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55795 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55796 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55797 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55798 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55799 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55800 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55801 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55802 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55803 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55804 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55805 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55806 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55807 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55808 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55809 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55810 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55811 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55812 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55813 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55814 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55815 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55816 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55817 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55818 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55819 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55820 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55821 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55822 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55823 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55824 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55825 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55826 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55827 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55828 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55829 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55830 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55831 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55832 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55833 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55834 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55835 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55836 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55837 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55838 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55839 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55840 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55841 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55842 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55843 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55844 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55845 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55846 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55847 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55848 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55849 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55850 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55851 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55852 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55853 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55854 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55855 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55856 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55857 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55858 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55859 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55860 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55861 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55862 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55863 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55864 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55865 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55866 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55867 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55868 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55869 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55870 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55871 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55872 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55873 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55874 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55875 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55876 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55877 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55878 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55879 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55880 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55881 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55882 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55883 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55884 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55885 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55886 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55887 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55888 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55889 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55890 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55891 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55892 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55893 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55894 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55895 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55896 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55897 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55898 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55899 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55900 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55901 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55902 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55903 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55904 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55905 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55906 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55907 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55908 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55909 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55910 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55911 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55912 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55913 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55914 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55915 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55916 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55917 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55918 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55919 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55920 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55921 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55922 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55923 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55924 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55925 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55926 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55927 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55928 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55929 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55930 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55931 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55932 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55933 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55934 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55935 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55936 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55937 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55938 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55939 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55940 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55941 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55942 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55943 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55944 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55945 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55946 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55947 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55948 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55949 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55950 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55951 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55952 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55953 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55954 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55955 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55956 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55957 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55958 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55959 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55960 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55961 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55962 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55963 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55964 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55965 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55966 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55967 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55968 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55969 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55970 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55971 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55972 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55973 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55974 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55975 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55976 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55977 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55978 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55979 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55980 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55981 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55982 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55983 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55984 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55985 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55986 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55987 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55988 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55989 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55990 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55991 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55992 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55993 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55994 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55995 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55996 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55997 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55998 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55999 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56000 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56001 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56002 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56003 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56004 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56005 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56006 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56007 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56008 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56009 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56010 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56011 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56012 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56013 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56014 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56015 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56016 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56017 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56018 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56019 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56020 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56021 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56022 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56023 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56024 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56025 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56026 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56027 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56028 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56029 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56030 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56031 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56032 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56033 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56034 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56035 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56036 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56037 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56038 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56039 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56040 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56041 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56042 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56043 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56044 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56045 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56046 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56047 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56048 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56049 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56050 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56051 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56052 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56053 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56054 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56055 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56056 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56057 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56058 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56059 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56060 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56061 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56062 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56063 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56064 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56065 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56066 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56067 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56068 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56069 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56070 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56071 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56072 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56073 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56074 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56075 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56076 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56077 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56078 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56079 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56080 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56081 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56082 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56083 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56084 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56085 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56086 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56087 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56088 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56089 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56090 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56091 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56092 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56093 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56094 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56095 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56096 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56097 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56098 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56099 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56100 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56101 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56102 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56103 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56104 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56105 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56106 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56107 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56108 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56109 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56110 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56111 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56112 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56113 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56114 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56115 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56116 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56117 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56118 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56119 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56120 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56121 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56122 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56123 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56124 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56125 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56126 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56127 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56128 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56129 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56130 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56131 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56132 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56133 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56134 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56135 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56136 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56137 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56138 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56139 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56140 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56141 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56142 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56143 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56144 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56145 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56146 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56147 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56148 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56149 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56150 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56151 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56152 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56153 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56154 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56155 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56156 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56157 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56158 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56159 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56160 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56161 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56162 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56163 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56164 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56165 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56166 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56167 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56168 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56169 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56170 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56171 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56172 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56173 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56174 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56175 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56176 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56177 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56178 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56179 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56180 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56181 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56182 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56183 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56184 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56185 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56186 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56187 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56188 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56189 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56190 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56191 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56192 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56193 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56194 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56195 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56196 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56197 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56198 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56199 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56200 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56201 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56202 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56203 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56204 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56205 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56206 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56207 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56208 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56209 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56210 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56211 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56212 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56213 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56214 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56215 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56216 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56217 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56218 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56219 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56220 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56221 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56222 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56223 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56224 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56225 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56226 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56227 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56228 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56229 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56230 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56231 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56232 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56233 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56234 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56235 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56236 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56237 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56238 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56239 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56240 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56241 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56242 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56243 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56244 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56245 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56246 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56247 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56248 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56249 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56250 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56251 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56252 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56253 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56254 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56255 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56256 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56257 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56258 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56259 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56260 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56261 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56262 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56263 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56264 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56265 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56266 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56267 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56268 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56269 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56270 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56271 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56272 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56273 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56274 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56275 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56276 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56277 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56278 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56279 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56280 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56281 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56282 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56283 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56284 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56285 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56286 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56287 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56288 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56289 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56290 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56291 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56292 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56293 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56294 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56295 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56296 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56297 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56298 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56299 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56300 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56301 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56302 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56303 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56304 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56305 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56306 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56307 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56308 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56309 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56310 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56311 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56312 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56313 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56314 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56315 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56316 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56317 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56318 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56319 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56320 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56321 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56322 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56323 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56324 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56325 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56326 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56327 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56328 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56329 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56330 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56331 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56332 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56333 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56334 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56335 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56336 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56337 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56338 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56339 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56340 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56341 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56342 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56343 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56344 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56345 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56346 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56347 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56348 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56349 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56350 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56351 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56352 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56353 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56354 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56355 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56356 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56357 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56358 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56359 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56360 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56361 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56362 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56363 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56364 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56365 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56366 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56367 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56368 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56369 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56370 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56371 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56372 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56373 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56374 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56375 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56376 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56377 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56378 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56379
56380 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56381
56382
56383 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56384
56385 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56386 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56387 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56388 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56389 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56390 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56391 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56392 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56393 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56394 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56395 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56396 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56397 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56398 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56399 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56400 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56401 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56402 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56403 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56404 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56405 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56406 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56407 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56408 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56409 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56410 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56411 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56412 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56413 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56414 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56415 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56416 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56417 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56418 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56419 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56420 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56421 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56422 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56423 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56424 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56425 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56426 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56427 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56428 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56429 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56430 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56431 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56432 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56433 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56434 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56435 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56436 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56437 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56438 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56439 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56440 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56441 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56442 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56443 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56444 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56445 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56446 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56447 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56448 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56449 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56450 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56451 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56452 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56453 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56454 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56455 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56456 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56457 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56458 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56459 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56460 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56461 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56462 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56463 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56464 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56465 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56466 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56467 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56468 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56469 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56470 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56471 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56472 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56473 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56474 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56475 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56476 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56477 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56478 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56479 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56480 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56481 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56482 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56483 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56484 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56485 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56486 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56487 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56488 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56489 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56490 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56491 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56492 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56493 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56494 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56495 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56496 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56497 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56498 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56499 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56500 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56501 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56502 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56503 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56504 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56505 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56506 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56507 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56508 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56509 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56510 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56511 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56512 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56513 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56514 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56515 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56516 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56517 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56518 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56519 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56520 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56521 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56522 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56523 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56524 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56525 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56526 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56527 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56528 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56529 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56530 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56531 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56532 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56533 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56534 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56535 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56536 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56537 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56538 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56539 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56540 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56541 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56542 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56543 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56544 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56545 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56546 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56547 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56548 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56549 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56550 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56551 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56552 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56553 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56554 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56555 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56556 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56557 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56558 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56559 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56560 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56561 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56562 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56563 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56564 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56565 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56566 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56567 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56568 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56569 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56570 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56571 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56572 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56573 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56574 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56575 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56576 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56577 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56578 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56579 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56580 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56581 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56582 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56583 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56584 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56585 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56586 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56587 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56588 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56589 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56590 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56591
56592 // Initialize threading, some globals and such
56593 __wxPyPreStart(d);
56594
56595
56596 // Although these are defined in __version__ they need to be here too so
56597 // that an assert can be done to ensure that the wxPython and the wxWindows
56598 // versions match.
56599 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56600 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56601 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56602
56603 }
56604
wxWidgets (Impactor)