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


4cae7ef5ccd4c44bdc6b3e4d78897f6662ace33f
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp,
2893
2894 wxArrayDouble2PyList_helper,
2895 wxPoint2D_LIST_helper
2896 };
2897
2898 #endif
2899
2900
2901 #if !WXWIN_COMPATIBILITY_2_4
2902 #define wxHIDE_READONLY 0
2903 #endif
2904
2905
2906 #define SWIG_From_long PyInt_FromLong
2907
2908
2909 SWIGINTERNINLINE PyObject *
2910 SWIG_From_int (int value)
2911 {
2912 return SWIG_From_long (value);
2913 }
2914
2915 static const wxString wxPyEmptyString(wxEmptyString);
2916 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2917 return self->GetClassInfo()->GetClassName();
2918 }
2919 SWIGINTERN void wxObject_Destroy(wxObject *self){
2920 delete self;
2921 }
2922
2923 #ifndef __WXMAC__
2924 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2925 #endif
2926
2927
2928 #include <limits.h>
2929 #ifndef LLONG_MIN
2930 # define LLONG_MIN LONG_LONG_MIN
2931 #endif
2932 #ifndef LLONG_MAX
2933 # define LLONG_MAX LONG_LONG_MAX
2934 #endif
2935 #ifndef ULLONG_MAX
2936 # define ULLONG_MAX ULONG_LONG_MAX
2937 #endif
2938
2939
2940 SWIGINTERN int
2941 SWIG_AsVal_long (PyObject* obj, long* val)
2942 {
2943 if (PyNumber_Check(obj)) {
2944 if (val) *val = PyInt_AsLong(obj);
2945 return SWIG_OK;
2946 }
2947 return SWIG_TypeError;
2948 }
2949
2950
2951 SWIGINTERN int
2952 SWIG_AsVal_int (PyObject * obj, int *val)
2953 {
2954 long v;
2955 int res = SWIG_AsVal_long (obj, &v);
2956 if (SWIG_IsOK(res)) {
2957 if ((v < INT_MIN || v > INT_MAX)) {
2958 return SWIG_OverflowError;
2959 } else {
2960 if (val) *val = static_cast< int >(v);
2961 }
2962 }
2963 return res;
2964 }
2965
2966 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return false;
2969 if ( ! wxSize_helper(other, &obj) ) {
2970 PyErr_Clear();
2971 return false;
2972 }
2973 return self->operator==(*obj);
2974 }
2975 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return true;
2978 if ( ! wxSize_helper(other, &obj)) {
2979 PyErr_Clear();
2980 return true;
2981 }
2982 return self->operator!=(*obj);
2983 }
2984
2985 #include <float.h>
2986
2987
2988 SWIGINTERN int
2989 SWIG_AsVal_double (PyObject *obj, double* val)
2990 {
2991 if (PyNumber_Check(obj)) {
2992 if (val) *val = PyFloat_AsDouble(obj);
2993 return SWIG_OK;
2994 }
2995 return SWIG_TypeError;
2996 }
2997
2998
2999 SWIGINTERN int
3000 SWIG_AsVal_float (PyObject * obj, float *val)
3001 {
3002 double v;
3003 int res = SWIG_AsVal_double (obj, &v);
3004 if (SWIG_IsOK(res)) {
3005 if ((v < -FLT_MAX || v > FLT_MAX)) {
3006 return SWIG_OverflowError;
3007 } else {
3008 if (val) *val = static_cast< float >(v);
3009 }
3010 }
3011 return res;
3012 }
3013
3014 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3016 PyObject* tup = PyTuple_New(2);
3017 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3018 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3019 wxPyEndBlockThreads(blocked);
3020 return tup;
3021 }
3022
3023 #define SWIG_From_double PyFloat_FromDouble
3024
3025 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3026 wxRealPoint temp, *obj = &temp;
3027 if ( other == Py_None ) return false;
3028 if ( ! wxRealPoint_helper(other, &obj) ) {
3029 PyErr_Clear();
3030 return false;
3031 }
3032 return self->operator==(*obj);
3033 }
3034 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return true;
3037 if ( ! wxRealPoint_helper(other, &obj)) {
3038 PyErr_Clear();
3039 return true;
3040 }
3041 return self->operator!=(*obj);
3042 }
3043 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3044 self->x = x;
3045 self->y = y;
3046 }
3047 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 PyObject* tup = PyTuple_New(2);
3050 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3051 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3052 wxPyEndBlockThreads(blocked);
3053 return tup;
3054 }
3055 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3056 wxPoint temp, *obj = &temp;
3057 if ( other == Py_None ) return false;
3058 if ( ! wxPoint_helper(other, &obj) ) {
3059 PyErr_Clear();
3060 return false;
3061 }
3062 return self->operator==(*obj);
3063 }
3064 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return true;
3067 if ( ! wxPoint_helper(other, &obj)) {
3068 PyErr_Clear();
3069 return true;
3070 }
3071 return self->operator!=(*obj);
3072 }
3073 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3074 self->x = x;
3075 self->y = y;
3076 }
3077 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3079 PyObject* tup = PyTuple_New(2);
3080 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3081 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3082 wxPyEndBlockThreads(blocked);
3083 return tup;
3084 }
3085 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3086 wxRect temp, *obj = &temp;
3087 if ( other == Py_None ) return false;
3088 if ( ! wxRect_helper(other, &obj) ) {
3089 PyErr_Clear();
3090 return false;
3091 }
3092 return self->operator==(*obj);
3093 }
3094 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return true;
3097 if ( ! wxRect_helper(other, &obj)) {
3098 PyErr_Clear();
3099 return true;
3100 }
3101 return self->operator!=(*obj);
3102 }
3103 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3104 self->x = x;
3105 self->y = y;
3106 self->width = width;
3107 self->height = height;
3108 }
3109 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3111 PyObject* tup = PyTuple_New(4);
3112 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3113 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3114 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3115 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3116 wxPyEndBlockThreads(blocked);
3117 return tup;
3118 }
3119
3120 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3121 wxRegion reg1(*r1);
3122 wxRegion reg2(*r2);
3123 wxRect dest(0,0,0,0);
3124 PyObject* obj;
3125
3126 reg1.Intersect(reg2);
3127 dest = reg1.GetBox();
3128
3129 if (dest != wxRect(0,0,0,0)) {
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxRect* newRect = new wxRect(dest);
3132 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3133 wxPyEndBlockThreads(blocked);
3134 return obj;
3135 }
3136 Py_INCREF(Py_None);
3137 return Py_None;
3138 }
3139
3140 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3141 wxPoint2D temp, *obj = &temp;
3142 if ( other == Py_None ) return false;
3143 if ( ! wxPoint2D_helper(other, &obj) ) {
3144 PyErr_Clear();
3145 return false;
3146 }
3147 return self->operator==(*obj);
3148 }
3149 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return true;
3152 if ( ! wxPoint2D_helper(other, &obj)) {
3153 PyErr_Clear();
3154 return true;
3155 }
3156 return self->operator!=(*obj);
3157 }
3158 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3159 self->m_x = x;
3160 self->m_y = y;
3161 }
3162 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3164 PyObject* tup = PyTuple_New(2);
3165 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3166 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3167 wxPyEndBlockThreads(blocked);
3168 return tup;
3169 }
3170
3171 #include "wx/wxPython/pyistream.h"
3172
3173 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3174 wxInputStream* wxis = wxPyCBInputStream::create(p);
3175 if (wxis)
3176 return new wxPyInputStream(wxis);
3177 else
3178 return NULL;
3179 }
3180
3181 SWIGINTERN swig_type_info*
3182 SWIG_pchar_descriptor()
3183 {
3184 static int init = 0;
3185 static swig_type_info* info = 0;
3186 if (!init) {
3187 info = SWIG_TypeQuery("_p_char");
3188 init = 1;
3189 }
3190 return info;
3191 }
3192
3193
3194 SWIGINTERNINLINE PyObject *
3195 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3196 {
3197 if (carray) {
3198 if (size > INT_MAX) {
3199 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3200 return pchar_descriptor ?
3201 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3202 } else {
3203 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3204 }
3205 } else {
3206 return SWIG_Py_Void();
3207 }
3208 }
3209
3210
3211 SWIGINTERNINLINE PyObject *
3212 SWIG_From_char (char c)
3213 {
3214 return SWIG_FromCharPtrAndSize(&c,1);
3215 }
3216
3217
3218 SWIGINTERNINLINE PyObject*
3219 SWIG_From_unsigned_SS_long (unsigned long value)
3220 {
3221 return (value > LONG_MAX) ?
3222 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3223 }
3224
3225
3226 SWIGINTERNINLINE PyObject *
3227 SWIG_From_size_t (size_t value)
3228 {
3229 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3230 }
3231
3232
3233 SWIGINTERN int
3234 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3235 {
3236 if (PyString_Check(obj)) {
3237 char *cstr; Py_ssize_t len;
3238 PyString_AsStringAndSize(obj, &cstr, &len);
3239 if (cptr) {
3240 if (alloc) {
3241 /*
3242 In python the user should not be able to modify the inner
3243 string representation. To warranty that, if you define
3244 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3245 buffer is always returned.
3246
3247 The default behavior is just to return the pointer value,
3248 so, be careful.
3249 */
3250 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3251 if (*alloc != SWIG_OLDOBJ)
3252 #else
3253 if (*alloc == SWIG_NEWOBJ)
3254 #endif
3255 {
3256 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3257 *alloc = SWIG_NEWOBJ;
3258 }
3259 else {
3260 *cptr = cstr;
3261 *alloc = SWIG_OLDOBJ;
3262 }
3263 } else {
3264 *cptr = PyString_AsString(obj);
3265 }
3266 }
3267 if (psize) *psize = len + 1;
3268 return SWIG_OK;
3269 } else {
3270 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3271 if (pchar_descriptor) {
3272 void* vptr = 0;
3273 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3274 if (cptr) *cptr = (char *) vptr;
3275 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3276 if (alloc) *alloc = SWIG_OLDOBJ;
3277 return SWIG_OK;
3278 }
3279 }
3280 }
3281 return SWIG_TypeError;
3282 }
3283
3284
3285 SWIGINTERN int
3286 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3287 {
3288 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3289 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3290 if (SWIG_IsOK(res)) {
3291 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3292 if (csize <= size) {
3293 if (val) {
3294 if (csize) memcpy(val, cptr, csize*sizeof(char));
3295 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3296 }
3297 if (alloc == SWIG_NEWOBJ) {
3298 delete[] cptr;
3299 res = SWIG_DelNewMask(res);
3300 }
3301 return res;
3302 }
3303 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3304 }
3305 return SWIG_TypeError;
3306 }
3307
3308
3309 SWIGINTERN int
3310 SWIG_AsVal_char (PyObject * obj, char *val)
3311 {
3312 int res = SWIG_AsCharArray(obj, val, 1);
3313 if (!SWIG_IsOK(res)) {
3314 long v;
3315 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3316 if (SWIG_IsOK(res)) {
3317 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3318 if (val) *val = static_cast< char >(v);
3319 } else {
3320 res = SWIG_OverflowError;
3321 }
3322 }
3323 }
3324 return res;
3325 }
3326
3327 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3328 // We use only strings for the streams, not unicode
3329 PyObject* str = PyObject_Str(obj);
3330 if (! str) {
3331 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3332 return;
3333 }
3334 self->Write(PyString_AS_STRING(str),
3335 PyString_GET_SIZE(str));
3336 Py_DECREF(str);
3337 }
3338
3339 #include "wx/wxPython/pyistream.h"
3340
3341
3342 class wxPyFileSystemHandler : public wxFileSystemHandler
3343 {
3344 public:
3345 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3346
3347 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3348 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3349 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3350 DEC_PYCALLBACK_STRING__pure(FindNext);
3351
3352 wxString GetProtocol(const wxString& location) {
3353 return wxFileSystemHandler::GetProtocol(location);
3354 }
3355
3356 wxString GetLeftLocation(const wxString& location) {
3357 return wxFileSystemHandler::GetLeftLocation(location);
3358 }
3359
3360 wxString GetAnchor(const wxString& location) {
3361 return wxFileSystemHandler::GetAnchor(location);
3362 }
3363
3364 wxString GetRightLocation(const wxString& location) {
3365 return wxFileSystemHandler::GetRightLocation(location);
3366 }
3367
3368 wxString GetMimeTypeFromExt(const wxString& location) {
3369 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3370 }
3371
3372 PYPRIVATE;
3373 };
3374
3375
3376 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3377 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3378 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3379 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3380
3381
3382 SWIGINTERN int
3383 SWIG_AsVal_bool (PyObject *obj, bool *val)
3384 {
3385 if (obj == Py_True) {
3386 if (val) *val = true;
3387 return SWIG_OK;
3388 } else if (obj == Py_False) {
3389 if (val) *val = false;
3390 return SWIG_OK;
3391 } else {
3392 long v = 0;
3393 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3394 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3395 return res;
3396 }
3397 }
3398
3399 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3400 wxFileName fname = wxFileSystem::URLToFileName(url);
3401 return fname.GetFullPath();
3402 }
3403
3404 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3405 wxImage& image,
3406 long type) {
3407 wxMemoryFSHandler::AddFile(filename, image, type);
3408 }
3409
3410 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3411 const wxBitmap& bitmap,
3412 long type) {
3413 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3414 }
3415
3416 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3417 PyObject* data) {
3418 if (! PyString_Check(data)) {
3419 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3420 "Expected string object"));
3421 return;
3422 }
3423
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 void* ptr = (void*)PyString_AsString(data);
3426 size_t size = PyString_Size(data);
3427 wxPyEndBlockThreads(blocked);
3428
3429 wxMemoryFSHandler::AddFile(filename, ptr, size);
3430 }
3431
3432
3433 #include "wx/wxPython/pyistream.h"
3434
3435
3436 SWIGINTERN int
3437 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3438 {
3439 long v = 0;
3440 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3441 return SWIG_TypeError;
3442 }
3443 else if (val)
3444 *val = (unsigned long)v;
3445 return SWIG_OK;
3446 }
3447
3448
3449 SWIGINTERN int
3450 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3451 {
3452 unsigned long v;
3453 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3454 if (SWIG_IsOK(res)) {
3455 if ((v > UCHAR_MAX)) {
3456 return SWIG_OverflowError;
3457 } else {
3458 if (val) *val = static_cast< unsigned char >(v);
3459 }
3460 }
3461 return res;
3462 }
3463
3464
3465 SWIGINTERNINLINE PyObject *
3466 SWIG_From_unsigned_SS_char (unsigned char value)
3467 {
3468 return SWIG_From_unsigned_SS_long (value);
3469 }
3470
3471 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3472 wxImageHistogramEntry e = (*self)[key];
3473 return e.value;
3474 }
3475 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3476 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3477 wxImageHistogramEntry e = (*self)[key];
3478 return e.value;
3479 }
3480 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3481 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3482 colour.Green(),
3483 colour.Blue());
3484 wxImageHistogramEntry e = (*self)[key];
3485 return e.value;
3486 }
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634
3635 wxImage* _ImageFromBuffer(int width, int height,
3636 buffer data, int DATASIZE,
3637 buffer alpha=NULL, int ALPHASIZE=0)
3638 {
3639 if (DATASIZE != width*height*3) {
3640 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3641 return NULL;
3642 }
3643 if (alpha != NULL) {
3644 if (ALPHASIZE != width*height) {
3645 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3646 return NULL;
3647 }
3648 return new wxImage(width, height, data, alpha, true);
3649 }
3650 return new wxImage(width, height, data, true);
3651 }
3652
3653 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3654 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3656 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3660 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3661 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3662 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3663 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3664 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3665 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3666 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3667 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3668
3669 #include <wx/quantize.h>
3670
3671 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3672 return wxQuantize::Quantize(src, dest,
3673 //NULL, // palette
3674 desiredNoColours,
3675 NULL, // eightBitData
3676 flags);
3677 }
3678 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3679 if (PyCallable_Check(func)) {
3680 self->Connect(id, lastId, eventType,
3681 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3682 new wxPyCallback(func));
3683 }
3684 else if (func == Py_None) {
3685 self->Disconnect(id, lastId, eventType,
3686 (wxObjectEventFunction)
3687 &wxPyCallback::EventThunker);
3688 }
3689 else {
3690 wxPyBLOCK_THREADS(
3691 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3692 }
3693 }
3694 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3695 return self->Disconnect(id, lastId, eventType,
3696 (wxObjectEventFunction)
3697 &wxPyCallback::EventThunker);
3698 }
3699 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3700 if (_self && _self != Py_None) {
3701 self->SetClientObject(new wxPyOORClientData(_self, incref));
3702 }
3703 else {
3704 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3705 if (data) {
3706 self->SetClientObject(NULL); // This will delete it too
3707 }
3708 }
3709 }
3710
3711 #if ! wxUSE_HOTKEY
3712 #define wxEVT_HOTKEY -9999
3713 #endif
3714
3715 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3716 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3717 if (data) {
3718 Py_INCREF(data->m_obj);
3719 return data->m_obj;
3720 } else {
3721 Py_INCREF(Py_None);
3722 return Py_None;
3723 }
3724 }
3725 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3726 wxPyClientData* data = new wxPyClientData(clientData);
3727 self->SetClientObject(data);
3728 }
3729 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3730 #if wxUSE_UNICODE
3731 return self->GetUnicodeKey();
3732 #else
3733 return 0;
3734 #endif
3735 }
3736 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3737 #if wxUSE_UNICODE
3738 self->m_uniChar = uniChar;
3739 #endif
3740 }
3741
3742 SWIGINTERNINLINE PyObject *
3743 SWIG_From_unsigned_SS_int (unsigned int value)
3744 {
3745 return SWIG_From_unsigned_SS_long (value);
3746 }
3747
3748
3749 SWIGINTERN int
3750 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3751 {
3752 unsigned long v;
3753 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3754 if (SWIG_IsOK(res)) {
3755 if ((v > UINT_MAX)) {
3756 return SWIG_OverflowError;
3757 } else {
3758 if (val) *val = static_cast< unsigned int >(v);
3759 }
3760 }
3761 return res;
3762 }
3763
3764 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3765 self->m_size = size;
3766 }
3767 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3768 int count = self->GetNumberOfFiles();
3769 wxString* files = self->GetFiles();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 PyObject* list = PyList_New(count);
3772
3773 if (!list) {
3774 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3775 wxPyEndBlockThreads(blocked);
3776 return NULL;
3777 }
3778
3779 for (int i=0; i<count; i++) {
3780 PyList_SetItem(list, i, wx2PyString(files[i]));
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return list;
3784 }
3785
3786
3787 SWIGINTERN wxPyApp *new_wxPyApp(){
3788 wxPythonApp = new wxPyApp();
3789 return wxPythonApp;
3790 }
3791 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3792 return wxPyTestDisplayAvailable();
3793 }
3794
3795 void wxApp_CleanUp() {
3796 __wxPyCleanup();
3797 }
3798
3799
3800 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3801
3802
3803
3804
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_FromCharPtr(const char *cptr)
3808 {
3809 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3810 }
3811
3812
3813 #if 0 // #ifdef __WXMAC__
3814
3815 // A dummy class that raises an exception if used...
3816 class wxEventLoop
3817 {
3818 public:
3819 wxEventLoop() { wxPyRaiseNotImplemented(); }
3820 int Run() { return 0; }
3821 void Exit(int rc = 0) {}
3822 bool Pending() const { return false; }
3823 bool Dispatch() { return false; }
3824 bool IsRunning() const { return false; }
3825 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3826 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3827 };
3828
3829 #else
3830
3831 #include <wx/evtloop.h>
3832
3833 #endif
3834
3835
3836
3837 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3838 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3839 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3840 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3841 wxWindowList& list = self->GetChildren();
3842 return wxPy_ConvertList(&list);
3843 }
3844 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3845 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3846 #if wxUSE_HOTKEY
3847 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3848 #else
3849 return false;
3850 #endif
3851 }
3852 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3853
3854
3855
3856 return false;
3857
3858 }
3859 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3860 return wxPyGetWinHandle(self);
3861 }
3862 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3863 self->AssociateHandle((WXWidget)handle);
3864 }
3865
3866 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3867 return wxWindow::FindWindowById(id, parent);
3868 }
3869
3870 wxWindow* wxFindWindowByName( const wxString& name,
3871 const wxWindow *parent = NULL ) {
3872 return wxWindow::FindWindowByName(name, parent);
3873 }
3874
3875 wxWindow* wxFindWindowByLabel( const wxString& label,
3876 const wxWindow *parent = NULL ) {
3877 return wxWindow::FindWindowByLabel(label, parent);
3878 }
3879
3880
3881 #ifdef __WXMSW__
3882 #include <wx/msw/private.h> // to get wxGetWindowId
3883 #endif
3884
3885
3886 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3887 #ifdef __WXMSW__
3888 WXHWND hWnd = (WXHWND)_hWnd;
3889 long id = wxGetWindowId(hWnd);
3890 wxWindow* win = new wxWindow;
3891 if (parent)
3892 parent->AddChild(win);
3893 win->SetEventHandler(win);
3894 win->SetHWND(hWnd);
3895 win->SetId(id);
3896 win->SubclassWin(hWnd);
3897 win->AdoptAttributesFromHWND();
3898 win->SetupColours();
3899 return win;
3900 #else
3901 wxPyRaiseNotImplemented();
3902 return NULL;
3903 #endif
3904 }
3905
3906
3907 PyObject* GetTopLevelWindows() {
3908 return wxPy_ConvertList(&wxTopLevelWindows);
3909 }
3910
3911
3912 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3915
3916 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3917
3918
3919 SWIGINTERNINLINE int
3920 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3921 {
3922 unsigned long v;
3923 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3924 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3925 return res;
3926 }
3927
3928 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3929 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3930 wxMenuItemList& list = self->GetMenuItems();
3931 return wxPy_ConvertList(&list);
3932 }
3933 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3934 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3935 static const wxString wxPyControlNameStr(wxControlNameStr);
3936 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3937 if (clientData) {
3938 wxPyClientData* data = new wxPyClientData(clientData);
3939 return self->Append(item, data);
3940 } else
3941 return self->Append(item);
3942 }
3943 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3944 if (clientData) {
3945 wxPyClientData* data = new wxPyClientData(clientData);
3946 return self->Insert(item, pos, data);
3947 } else
3948 return self->Insert(item, pos);
3949 }
3950 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3951 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3952 if (data) {
3953 Py_INCREF(data->m_obj);
3954 return data->m_obj;
3955 } else {
3956 Py_INCREF(Py_None);
3957 return Py_None;
3958 }
3959 }
3960 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3961 wxPyClientData* data = new wxPyClientData(clientData);
3962 self->SetClientObject(n, data);
3963 }
3964
3965
3966 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3967 wxPyUserData* data = NULL;
3968 if ( userData ) {
3969 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3970 data = new wxPyUserData(userData);
3971 wxPyEndBlockThreads(blocked);
3972 }
3973 return new wxSizerItem(window, proportion, flag, border, data);
3974 }
3975 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3976 wxPyUserData* data = NULL;
3977 if ( userData ) {
3978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3979 data = new wxPyUserData(userData);
3980 wxPyEndBlockThreads(blocked);
3981 }
3982 return new wxSizerItem(width, height, proportion, flag, border, data);
3983 }
3984 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3985 wxPyUserData* data = NULL;
3986 if ( userData ) {
3987 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3988 data = new wxPyUserData(userData);
3989 wxPyEndBlockThreads(blocked);
3990 }
3991 return new wxSizerItem(sizer, proportion, flag, border, data);
3992 }
3993
3994 SWIGINTERNINLINE PyObject *
3995 SWIG_From_float (float value)
3996 {
3997 return SWIG_From_double (value);
3998 }
3999
4000 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4001 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4002 if (data) {
4003 Py_INCREF(data->m_obj);
4004 return data->m_obj;
4005 } else {
4006 Py_INCREF(Py_None);
4007 return Py_None;
4008 }
4009 }
4010 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4011 wxPyUserData* data = NULL;
4012 if ( userData ) {
4013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4014 data = new wxPyUserData(userData);
4015 wxPyEndBlockThreads(blocked);
4016 }
4017 self->SetUserData(data);
4018 }
4019
4020 // Figure out the type of the sizer item
4021
4022 struct wxPySizerItemInfo {
4023 wxPySizerItemInfo()
4024 : window(NULL), sizer(NULL), gotSize(false),
4025 size(wxDefaultSize), gotPos(false), pos(-1)
4026 {}
4027
4028 wxWindow* window;
4029 wxSizer* sizer;
4030 bool gotSize;
4031 wxSize size;
4032 bool gotPos;
4033 int pos;
4034 };
4035
4036 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4037
4038 wxPySizerItemInfo info;
4039 wxSize size;
4040 wxSize* sizePtr = &size;
4041
4042 // Find out what the type of the item is
4043 // try wxWindow
4044 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4045 PyErr_Clear();
4046 info.window = NULL;
4047
4048 // try wxSizer
4049 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4050 PyErr_Clear();
4051 info.sizer = NULL;
4052
4053 // try wxSize or (w,h)
4054 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4055 info.size = *sizePtr;
4056 info.gotSize = true;
4057 }
4058
4059 // or a single int
4060 if (checkIdx && PyInt_Check(item)) {
4061 info.pos = PyInt_AsLong(item);
4062 info.gotPos = true;
4063 }
4064 }
4065 }
4066
4067 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4068 // no expected type, figure out what kind of error message to generate
4069 if ( !checkSize && !checkIdx )
4070 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4071 else if ( checkSize && !checkIdx )
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4073 else if ( !checkSize && checkIdx)
4074 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4075 else
4076 // can this one happen?
4077 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4078 }
4079
4080 return info;
4081 }
4082
4083 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4084 if (!self->GetClientObject())
4085 self->SetClientObject(new wxPyOORClientData(_self));
4086 }
4087 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4088
4089 wxPyUserData* data = NULL;
4090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4092 if ( userData && (info.window || info.sizer || info.gotSize) )
4093 data = new wxPyUserData(userData);
4094 if ( info.sizer )
4095 PyObject_SetAttrString(item,"thisown",Py_False);
4096 wxPyEndBlockThreads(blocked);
4097
4098 // Now call the real Add method if a valid item type was found
4099 if ( info.window )
4100 return self->Add(info.window, proportion, flag, border, data);
4101 else if ( info.sizer )
4102 return self->Add(info.sizer, proportion, flag, border, data);
4103 else if (info.gotSize)
4104 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4105 proportion, flag, border, data);
4106 else
4107 return NULL;
4108 }
4109 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4110
4111 wxPyUserData* data = NULL;
4112 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4113 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4114 if ( userData && (info.window || info.sizer || info.gotSize) )
4115 data = new wxPyUserData(userData);
4116 if ( info.sizer )
4117 PyObject_SetAttrString(item,"thisown",Py_False);
4118 wxPyEndBlockThreads(blocked);
4119
4120 // Now call the real Insert method if a valid item type was found
4121 if ( info.window )
4122 return self->Insert(before, info.window, proportion, flag, border, data);
4123 else if ( info.sizer )
4124 return self->Insert(before, info.sizer, proportion, flag, border, data);
4125 else if (info.gotSize)
4126 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4127 proportion, flag, border, data);
4128 else
4129 return NULL;
4130 }
4131 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4132
4133 wxPyUserData* data = NULL;
4134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4135 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4136 if ( userData && (info.window || info.sizer || info.gotSize) )
4137 data = new wxPyUserData(userData);
4138 if ( info.sizer )
4139 PyObject_SetAttrString(item,"thisown",Py_False);
4140 wxPyEndBlockThreads(blocked);
4141
4142 // Now call the real Prepend method if a valid item type was found
4143 if ( info.window )
4144 return self->Prepend(info.window, proportion, flag, border, data);
4145 else if ( info.sizer )
4146 return self->Prepend(info.sizer, proportion, flag, border, data);
4147 else if (info.gotSize)
4148 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4149 proportion, flag, border, data);
4150 else
4151 return NULL;
4152 }
4153 SWIGINTERN bool wxSizer_Remove(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->Remove(info.window);
4159 else if ( info.sizer )
4160 return self->Remove(info.sizer);
4161 else if ( info.gotPos )
4162 return self->Remove(info.pos);
4163 else
4164 return false;
4165 }
4166 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4168 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4169 wxPyEndBlockThreads(blocked);
4170 if ( info.window )
4171 return self->Detach(info.window);
4172 else if ( info.sizer )
4173 return self->Detach(info.sizer);
4174 else if ( info.gotPos )
4175 return self->Detach(info.pos);
4176 else
4177 return false;
4178 }
4179 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4182 wxPyEndBlockThreads(blocked);
4183 if ( info.window )
4184 return self->GetItem(info.window);
4185 else if ( info.sizer )
4186 return self->GetItem(info.sizer);
4187 else if ( info.gotPos )
4188 return self->GetItem(info.pos);
4189 else
4190 return NULL;
4191 }
4192 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4194 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4195 wxPyEndBlockThreads(blocked);
4196 if ( info.window )
4197 self->SetItemMinSize(info.window, size);
4198 else if ( info.sizer )
4199 self->SetItemMinSize(info.sizer, size);
4200 else if ( info.gotPos )
4201 self->SetItemMinSize(info.pos, size);
4202 }
4203 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4204 wxSizerItemList& list = self->GetChildren();
4205 return wxPy_ConvertList(&list);
4206 }
4207 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4209 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4210 wxPyEndBlockThreads(blocked);
4211 if ( info.window )
4212 return self->Show(info.window, show, recursive);
4213 else if ( info.sizer )
4214 return self->Show(info.sizer, show, recursive);
4215 else if ( info.gotPos )
4216 return self->Show(info.pos, show);
4217 else
4218 return false;
4219 }
4220 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->IsShown(info.window);
4226 else if ( info.sizer )
4227 return self->IsShown(info.sizer);
4228 else if ( info.gotPos )
4229 return self->IsShown(info.pos);
4230 else
4231 return false;
4232 }
4233
4234 // See pyclasses.h
4235 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4236 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4237 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4238
4239
4240
4241
4242 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4243 {
4244 if (source == Py_None) {
4245 **obj = wxGBPosition(-1,-1);
4246 return true;
4247 }
4248 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4249 }
4250
4251 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4252 {
4253 if (source == Py_None) {
4254 **obj = wxGBSpan(-1,-1);
4255 return true;
4256 }
4257 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4258 }
4259
4260
4261 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4262 wxGBPosition temp, *obj = &temp;
4263 if ( other == Py_None ) return false;
4264 if ( ! wxGBPosition_helper(other, &obj) ) {
4265 PyErr_Clear();
4266 return false;
4267 }
4268 return self->operator==(*obj);
4269 }
4270 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4271 wxGBPosition temp, *obj = &temp;
4272 if ( other == Py_None ) return true;
4273 if ( ! wxGBPosition_helper(other, &obj)) {
4274 PyErr_Clear();
4275 return true;
4276 }
4277 return self->operator!=(*obj);
4278 }
4279 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4280 self->SetRow(row);
4281 self->SetCol(col);
4282 }
4283 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4285 PyObject* tup = PyTuple_New(2);
4286 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4287 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4288 wxPyEndBlockThreads(blocked);
4289 return tup;
4290 }
4291 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4292 wxGBSpan temp, *obj = &temp;
4293 if ( other == Py_None ) return false;
4294 if ( ! wxGBSpan_helper(other, &obj) ) {
4295 PyErr_Clear();
4296 return false;
4297 }
4298 return self->operator==(*obj);
4299 }
4300 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4301 wxGBSpan temp, *obj = &temp;
4302 if ( other == Py_None ) return true;
4303 if ( ! wxGBSpan_helper(other, &obj)) {
4304 PyErr_Clear();
4305 return true;
4306 }
4307 return self->operator!=(*obj);
4308 }
4309 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4310 self->SetRowspan(rowspan);
4311 self->SetColspan(colspan);
4312 }
4313 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4314 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4315 PyObject* tup = PyTuple_New(2);
4316 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4317 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4318 wxPyEndBlockThreads(blocked);
4319 return tup;
4320 }
4321 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4322 wxPyUserData* data = NULL;
4323 if ( userData ) {
4324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4325 data = new wxPyUserData(userData);
4326 wxPyEndBlockThreads(blocked);
4327 }
4328 return new wxGBSizerItem(window, pos, span, flag, border, data);
4329 }
4330 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4331 wxPyUserData* data = NULL;
4332 if ( userData ) {
4333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4334 data = new wxPyUserData(userData);
4335 wxPyEndBlockThreads(blocked);
4336 }
4337 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4338 }
4339 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4340 wxPyUserData* data = NULL;
4341 if ( userData ) {
4342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4343 data = new wxPyUserData(userData);
4344 wxPyEndBlockThreads(blocked);
4345 }
4346 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4347 }
4348 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4349 int row, col;
4350 self->GetEndPos(row, col);
4351 return wxGBPosition(row, col);
4352 }
4353 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4354
4355 wxPyUserData* data = NULL;
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4358 if ( userData && (info.window || info.sizer || info.gotSize) )
4359 data = new wxPyUserData(userData);
4360 if ( info.sizer )
4361 PyObject_SetAttrString(item,"thisown",Py_False);
4362 wxPyEndBlockThreads(blocked);
4363
4364 // Now call the real Add method if a valid item type was found
4365 if ( info.window )
4366 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4367 else if ( info.sizer )
4368 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4369 else if (info.gotSize)
4370 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4371 pos, span, flag, border, data);
4372 return NULL;
4373 }
4374
4375
4376 #ifdef __cplusplus
4377 extern "C" {
4378 #endif
4379 SWIGINTERN int EmptyString_set(PyObject *) {
4380 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4381 return 1;
4382 }
4383
4384
4385 SWIGINTERN PyObject *EmptyString_get(void) {
4386 PyObject *pyobj = 0;
4387
4388 {
4389 #if wxUSE_UNICODE
4390 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4391 #else
4392 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4393 #endif
4394 }
4395 return pyobj;
4396 }
4397
4398
4399 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4400 PyObject *resultobj = 0;
4401 wxObject *arg1 = (wxObject *) 0 ;
4402 wxString result;
4403 void *argp1 = 0 ;
4404 int res1 = 0 ;
4405 PyObject *swig_obj[1] ;
4406
4407 if (!args) SWIG_fail;
4408 swig_obj[0] = args;
4409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4410 if (!SWIG_IsOK(res1)) {
4411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4412 }
4413 arg1 = reinterpret_cast< wxObject * >(argp1);
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 result = wxObject_GetClassName(arg1);
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 {
4421 #if wxUSE_UNICODE
4422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4423 #else
4424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4425 #endif
4426 }
4427 return resultobj;
4428 fail:
4429 return NULL;
4430 }
4431
4432
4433 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4434 PyObject *resultobj = 0;
4435 wxObject *arg1 = (wxObject *) 0 ;
4436 void *argp1 = 0 ;
4437 int res1 = 0 ;
4438 PyObject *swig_obj[1] ;
4439
4440 if (!args) SWIG_fail;
4441 swig_obj[0] = args;
4442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4443 if (!SWIG_IsOK(res1)) {
4444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4445 }
4446 arg1 = reinterpret_cast< wxObject * >(argp1);
4447 {
4448 PyThreadState* __tstate = wxPyBeginAllowThreads();
4449 wxObject_Destroy(arg1);
4450 wxPyEndAllowThreads(__tstate);
4451 if (PyErr_Occurred()) SWIG_fail;
4452 }
4453 resultobj = SWIG_Py_Void();
4454 return resultobj;
4455 fail:
4456 return NULL;
4457 }
4458
4459
4460 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4461 PyObject *obj;
4462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4463 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4464 return SWIG_Py_Void();
4465 }
4466
4467 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4468 PyObject *resultobj = 0;
4469 wxSize *arg1 = (wxSize *) 0 ;
4470 int arg2 ;
4471 void *argp1 = 0 ;
4472 int res1 = 0 ;
4473 int val2 ;
4474 int ecode2 = 0 ;
4475 PyObject *swig_obj[2] ;
4476
4477 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4479 if (!SWIG_IsOK(res1)) {
4480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4481 }
4482 arg1 = reinterpret_cast< wxSize * >(argp1);
4483 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4484 if (!SWIG_IsOK(ecode2)) {
4485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4486 }
4487 arg2 = static_cast< int >(val2);
4488 if (arg1) (arg1)->x = arg2;
4489
4490 resultobj = SWIG_Py_Void();
4491 return resultobj;
4492 fail:
4493 return NULL;
4494 }
4495
4496
4497 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4498 PyObject *resultobj = 0;
4499 wxSize *arg1 = (wxSize *) 0 ;
4500 int result;
4501 void *argp1 = 0 ;
4502 int res1 = 0 ;
4503 PyObject *swig_obj[1] ;
4504
4505 if (!args) SWIG_fail;
4506 swig_obj[0] = args;
4507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4508 if (!SWIG_IsOK(res1)) {
4509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4510 }
4511 arg1 = reinterpret_cast< wxSize * >(argp1);
4512 result = (int) ((arg1)->x);
4513 resultobj = SWIG_From_int(static_cast< int >(result));
4514 return resultobj;
4515 fail:
4516 return NULL;
4517 }
4518
4519
4520 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4521 PyObject *resultobj = 0;
4522 wxSize *arg1 = (wxSize *) 0 ;
4523 int arg2 ;
4524 void *argp1 = 0 ;
4525 int res1 = 0 ;
4526 int val2 ;
4527 int ecode2 = 0 ;
4528 PyObject *swig_obj[2] ;
4529
4530 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4532 if (!SWIG_IsOK(res1)) {
4533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4534 }
4535 arg1 = reinterpret_cast< wxSize * >(argp1);
4536 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4537 if (!SWIG_IsOK(ecode2)) {
4538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4539 }
4540 arg2 = static_cast< int >(val2);
4541 if (arg1) (arg1)->y = arg2;
4542
4543 resultobj = SWIG_Py_Void();
4544 return resultobj;
4545 fail:
4546 return NULL;
4547 }
4548
4549
4550 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4551 PyObject *resultobj = 0;
4552 wxSize *arg1 = (wxSize *) 0 ;
4553 int result;
4554 void *argp1 = 0 ;
4555 int res1 = 0 ;
4556 PyObject *swig_obj[1] ;
4557
4558 if (!args) SWIG_fail;
4559 swig_obj[0] = args;
4560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4561 if (!SWIG_IsOK(res1)) {
4562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4563 }
4564 arg1 = reinterpret_cast< wxSize * >(argp1);
4565 result = (int) ((arg1)->y);
4566 resultobj = SWIG_From_int(static_cast< int >(result));
4567 return resultobj;
4568 fail:
4569 return NULL;
4570 }
4571
4572
4573 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4574 PyObject *resultobj = 0;
4575 int arg1 = (int) 0 ;
4576 int arg2 = (int) 0 ;
4577 wxSize *result = 0 ;
4578 int val1 ;
4579 int ecode1 = 0 ;
4580 int val2 ;
4581 int ecode2 = 0 ;
4582 PyObject * obj0 = 0 ;
4583 PyObject * obj1 = 0 ;
4584 char * kwnames[] = {
4585 (char *) "w",(char *) "h", NULL
4586 };
4587
4588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4589 if (obj0) {
4590 ecode1 = SWIG_AsVal_int(obj0, &val1);
4591 if (!SWIG_IsOK(ecode1)) {
4592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4593 }
4594 arg1 = static_cast< int >(val1);
4595 }
4596 if (obj1) {
4597 ecode2 = SWIG_AsVal_int(obj1, &val2);
4598 if (!SWIG_IsOK(ecode2)) {
4599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4600 }
4601 arg2 = static_cast< int >(val2);
4602 }
4603 {
4604 PyThreadState* __tstate = wxPyBeginAllowThreads();
4605 result = (wxSize *)new wxSize(arg1,arg2);
4606 wxPyEndAllowThreads(__tstate);
4607 if (PyErr_Occurred()) SWIG_fail;
4608 }
4609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4610 return resultobj;
4611 fail:
4612 return NULL;
4613 }
4614
4615
4616 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4617 PyObject *resultobj = 0;
4618 wxSize *arg1 = (wxSize *) 0 ;
4619 void *argp1 = 0 ;
4620 int res1 = 0 ;
4621 PyObject *swig_obj[1] ;
4622
4623 if (!args) SWIG_fail;
4624 swig_obj[0] = args;
4625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4626 if (!SWIG_IsOK(res1)) {
4627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4628 }
4629 arg1 = reinterpret_cast< wxSize * >(argp1);
4630 {
4631 PyThreadState* __tstate = wxPyBeginAllowThreads();
4632 delete arg1;
4633
4634 wxPyEndAllowThreads(__tstate);
4635 if (PyErr_Occurred()) SWIG_fail;
4636 }
4637 resultobj = SWIG_Py_Void();
4638 return resultobj;
4639 fail:
4640 return NULL;
4641 }
4642
4643
4644 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4645 PyObject *resultobj = 0;
4646 wxSize *arg1 = (wxSize *) 0 ;
4647 PyObject *arg2 = (PyObject *) 0 ;
4648 bool result;
4649 void *argp1 = 0 ;
4650 int res1 = 0 ;
4651 PyObject * obj0 = 0 ;
4652 PyObject * obj1 = 0 ;
4653 char * kwnames[] = {
4654 (char *) "self",(char *) "other", NULL
4655 };
4656
4657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4659 if (!SWIG_IsOK(res1)) {
4660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4661 }
4662 arg1 = reinterpret_cast< wxSize * >(argp1);
4663 arg2 = obj1;
4664 {
4665 result = (bool)wxSize___eq__(arg1,arg2);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 {
4669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4670 }
4671 return resultobj;
4672 fail:
4673 return NULL;
4674 }
4675
4676
4677 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4678 PyObject *resultobj = 0;
4679 wxSize *arg1 = (wxSize *) 0 ;
4680 PyObject *arg2 = (PyObject *) 0 ;
4681 bool result;
4682 void *argp1 = 0 ;
4683 int res1 = 0 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char * kwnames[] = {
4687 (char *) "self",(char *) "other", NULL
4688 };
4689
4690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4692 if (!SWIG_IsOK(res1)) {
4693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4694 }
4695 arg1 = reinterpret_cast< wxSize * >(argp1);
4696 arg2 = obj1;
4697 {
4698 result = (bool)wxSize___ne__(arg1,arg2);
4699 if (PyErr_Occurred()) SWIG_fail;
4700 }
4701 {
4702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4703 }
4704 return resultobj;
4705 fail:
4706 return NULL;
4707 }
4708
4709
4710 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4711 PyObject *resultobj = 0;
4712 wxSize *arg1 = (wxSize *) 0 ;
4713 wxSize *arg2 = 0 ;
4714 wxSize result;
4715 void *argp1 = 0 ;
4716 int res1 = 0 ;
4717 wxSize temp2 ;
4718 PyObject * obj0 = 0 ;
4719 PyObject * obj1 = 0 ;
4720 char * kwnames[] = {
4721 (char *) "self",(char *) "sz", NULL
4722 };
4723
4724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4726 if (!SWIG_IsOK(res1)) {
4727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4728 }
4729 arg1 = reinterpret_cast< wxSize * >(argp1);
4730 {
4731 arg2 = &temp2;
4732 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4733 }
4734 {
4735 PyThreadState* __tstate = wxPyBeginAllowThreads();
4736 result = (arg1)->operator +((wxSize const &)*arg2);
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4748 PyObject *resultobj = 0;
4749 wxSize *arg1 = (wxSize *) 0 ;
4750 wxSize *arg2 = 0 ;
4751 wxSize result;
4752 void *argp1 = 0 ;
4753 int res1 = 0 ;
4754 wxSize temp2 ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 char * kwnames[] = {
4758 (char *) "self",(char *) "sz", NULL
4759 };
4760
4761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4763 if (!SWIG_IsOK(res1)) {
4764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4765 }
4766 arg1 = reinterpret_cast< wxSize * >(argp1);
4767 {
4768 arg2 = &temp2;
4769 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4770 }
4771 {
4772 PyThreadState* __tstate = wxPyBeginAllowThreads();
4773 result = (arg1)->operator -((wxSize const &)*arg2);
4774 wxPyEndAllowThreads(__tstate);
4775 if (PyErr_Occurred()) SWIG_fail;
4776 }
4777 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4778 return resultobj;
4779 fail:
4780 return NULL;
4781 }
4782
4783
4784 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj = 0;
4786 wxSize *arg1 = (wxSize *) 0 ;
4787 wxSize *arg2 = 0 ;
4788 void *argp1 = 0 ;
4789 int res1 = 0 ;
4790 wxSize temp2 ;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 char * kwnames[] = {
4794 (char *) "self",(char *) "sz", NULL
4795 };
4796
4797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4799 if (!SWIG_IsOK(res1)) {
4800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4801 }
4802 arg1 = reinterpret_cast< wxSize * >(argp1);
4803 {
4804 arg2 = &temp2;
4805 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4806 }
4807 {
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 (arg1)->IncTo((wxSize const &)*arg2);
4810 wxPyEndAllowThreads(__tstate);
4811 if (PyErr_Occurred()) SWIG_fail;
4812 }
4813 resultobj = SWIG_Py_Void();
4814 return resultobj;
4815 fail:
4816 return NULL;
4817 }
4818
4819
4820 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4821 PyObject *resultobj = 0;
4822 wxSize *arg1 = (wxSize *) 0 ;
4823 wxSize *arg2 = 0 ;
4824 void *argp1 = 0 ;
4825 int res1 = 0 ;
4826 wxSize temp2 ;
4827 PyObject * obj0 = 0 ;
4828 PyObject * obj1 = 0 ;
4829 char * kwnames[] = {
4830 (char *) "self",(char *) "sz", NULL
4831 };
4832
4833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4835 if (!SWIG_IsOK(res1)) {
4836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4837 }
4838 arg1 = reinterpret_cast< wxSize * >(argp1);
4839 {
4840 arg2 = &temp2;
4841 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4842 }
4843 {
4844 PyThreadState* __tstate = wxPyBeginAllowThreads();
4845 (arg1)->DecTo((wxSize const &)*arg2);
4846 wxPyEndAllowThreads(__tstate);
4847 if (PyErr_Occurred()) SWIG_fail;
4848 }
4849 resultobj = SWIG_Py_Void();
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj = 0;
4858 wxSize *arg1 = (wxSize *) 0 ;
4859 int arg2 ;
4860 int arg3 ;
4861 void *argp1 = 0 ;
4862 int res1 = 0 ;
4863 int val2 ;
4864 int ecode2 = 0 ;
4865 int val3 ;
4866 int ecode3 = 0 ;
4867 PyObject * obj0 = 0 ;
4868 PyObject * obj1 = 0 ;
4869 PyObject * obj2 = 0 ;
4870 char * kwnames[] = {
4871 (char *) "self",(char *) "dx",(char *) "dy", NULL
4872 };
4873
4874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4876 if (!SWIG_IsOK(res1)) {
4877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4878 }
4879 arg1 = reinterpret_cast< wxSize * >(argp1);
4880 ecode2 = SWIG_AsVal_int(obj1, &val2);
4881 if (!SWIG_IsOK(ecode2)) {
4882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4883 }
4884 arg2 = static_cast< int >(val2);
4885 ecode3 = SWIG_AsVal_int(obj2, &val3);
4886 if (!SWIG_IsOK(ecode3)) {
4887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4888 }
4889 arg3 = static_cast< int >(val3);
4890 {
4891 PyThreadState* __tstate = wxPyBeginAllowThreads();
4892 (arg1)->IncBy(arg2,arg3);
4893 wxPyEndAllowThreads(__tstate);
4894 if (PyErr_Occurred()) SWIG_fail;
4895 }
4896 resultobj = SWIG_Py_Void();
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4904 PyObject *resultobj = 0;
4905 wxSize *arg1 = (wxSize *) 0 ;
4906 int arg2 ;
4907 int arg3 ;
4908 void *argp1 = 0 ;
4909 int res1 = 0 ;
4910 int val2 ;
4911 int ecode2 = 0 ;
4912 int val3 ;
4913 int ecode3 = 0 ;
4914 PyObject * obj0 = 0 ;
4915 PyObject * obj1 = 0 ;
4916 PyObject * obj2 = 0 ;
4917 char * kwnames[] = {
4918 (char *) "self",(char *) "dx",(char *) "dy", NULL
4919 };
4920
4921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4923 if (!SWIG_IsOK(res1)) {
4924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4925 }
4926 arg1 = reinterpret_cast< wxSize * >(argp1);
4927 ecode2 = SWIG_AsVal_int(obj1, &val2);
4928 if (!SWIG_IsOK(ecode2)) {
4929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4930 }
4931 arg2 = static_cast< int >(val2);
4932 ecode3 = SWIG_AsVal_int(obj2, &val3);
4933 if (!SWIG_IsOK(ecode3)) {
4934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4935 }
4936 arg3 = static_cast< int >(val3);
4937 {
4938 PyThreadState* __tstate = wxPyBeginAllowThreads();
4939 (arg1)->DecBy(arg2,arg3);
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 resultobj = SWIG_Py_Void();
4944 return resultobj;
4945 fail:
4946 return NULL;
4947 }
4948
4949
4950 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4951 PyObject *resultobj = 0;
4952 wxSize *arg1 = (wxSize *) 0 ;
4953 float arg2 ;
4954 float arg3 ;
4955 void *argp1 = 0 ;
4956 int res1 = 0 ;
4957 float val2 ;
4958 int ecode2 = 0 ;
4959 float val3 ;
4960 int ecode3 = 0 ;
4961 PyObject * obj0 = 0 ;
4962 PyObject * obj1 = 0 ;
4963 PyObject * obj2 = 0 ;
4964 char * kwnames[] = {
4965 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4966 };
4967
4968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4970 if (!SWIG_IsOK(res1)) {
4971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4972 }
4973 arg1 = reinterpret_cast< wxSize * >(argp1);
4974 ecode2 = SWIG_AsVal_float(obj1, &val2);
4975 if (!SWIG_IsOK(ecode2)) {
4976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4977 }
4978 arg2 = static_cast< float >(val2);
4979 ecode3 = SWIG_AsVal_float(obj2, &val3);
4980 if (!SWIG_IsOK(ecode3)) {
4981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4982 }
4983 arg3 = static_cast< float >(val3);
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 (arg1)->Scale(arg2,arg3);
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 resultobj = SWIG_Py_Void();
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4998 PyObject *resultobj = 0;
4999 wxSize *arg1 = (wxSize *) 0 ;
5000 int arg2 ;
5001 int arg3 ;
5002 void *argp1 = 0 ;
5003 int res1 = 0 ;
5004 int val2 ;
5005 int ecode2 = 0 ;
5006 int val3 ;
5007 int ecode3 = 0 ;
5008 PyObject * obj0 = 0 ;
5009 PyObject * obj1 = 0 ;
5010 PyObject * obj2 = 0 ;
5011 char * kwnames[] = {
5012 (char *) "self",(char *) "w",(char *) "h", NULL
5013 };
5014
5015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5017 if (!SWIG_IsOK(res1)) {
5018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5019 }
5020 arg1 = reinterpret_cast< wxSize * >(argp1);
5021 ecode2 = SWIG_AsVal_int(obj1, &val2);
5022 if (!SWIG_IsOK(ecode2)) {
5023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5024 }
5025 arg2 = static_cast< int >(val2);
5026 ecode3 = SWIG_AsVal_int(obj2, &val3);
5027 if (!SWIG_IsOK(ecode3)) {
5028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5029 }
5030 arg3 = static_cast< int >(val3);
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 (arg1)->Set(arg2,arg3);
5034 wxPyEndAllowThreads(__tstate);
5035 if (PyErr_Occurred()) SWIG_fail;
5036 }
5037 resultobj = SWIG_Py_Void();
5038 return resultobj;
5039 fail:
5040 return NULL;
5041 }
5042
5043
5044 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5045 PyObject *resultobj = 0;
5046 wxSize *arg1 = (wxSize *) 0 ;
5047 int arg2 ;
5048 void *argp1 = 0 ;
5049 int res1 = 0 ;
5050 int val2 ;
5051 int ecode2 = 0 ;
5052 PyObject * obj0 = 0 ;
5053 PyObject * obj1 = 0 ;
5054 char * kwnames[] = {
5055 (char *) "self",(char *) "w", NULL
5056 };
5057
5058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5060 if (!SWIG_IsOK(res1)) {
5061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5062 }
5063 arg1 = reinterpret_cast< wxSize * >(argp1);
5064 ecode2 = SWIG_AsVal_int(obj1, &val2);
5065 if (!SWIG_IsOK(ecode2)) {
5066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5067 }
5068 arg2 = static_cast< int >(val2);
5069 {
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 (arg1)->SetWidth(arg2);
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 resultobj = SWIG_Py_Void();
5076 return resultobj;
5077 fail:
5078 return NULL;
5079 }
5080
5081
5082 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5083 PyObject *resultobj = 0;
5084 wxSize *arg1 = (wxSize *) 0 ;
5085 int arg2 ;
5086 void *argp1 = 0 ;
5087 int res1 = 0 ;
5088 int val2 ;
5089 int ecode2 = 0 ;
5090 PyObject * obj0 = 0 ;
5091 PyObject * obj1 = 0 ;
5092 char * kwnames[] = {
5093 (char *) "self",(char *) "h", NULL
5094 };
5095
5096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5098 if (!SWIG_IsOK(res1)) {
5099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5100 }
5101 arg1 = reinterpret_cast< wxSize * >(argp1);
5102 ecode2 = SWIG_AsVal_int(obj1, &val2);
5103 if (!SWIG_IsOK(ecode2)) {
5104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5105 }
5106 arg2 = static_cast< int >(val2);
5107 {
5108 PyThreadState* __tstate = wxPyBeginAllowThreads();
5109 (arg1)->SetHeight(arg2);
5110 wxPyEndAllowThreads(__tstate);
5111 if (PyErr_Occurred()) SWIG_fail;
5112 }
5113 resultobj = SWIG_Py_Void();
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 PyObject *resultobj = 0;
5122 wxSize *arg1 = (wxSize *) 0 ;
5123 int result;
5124 void *argp1 = 0 ;
5125 int res1 = 0 ;
5126 PyObject *swig_obj[1] ;
5127
5128 if (!args) SWIG_fail;
5129 swig_obj[0] = args;
5130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5131 if (!SWIG_IsOK(res1)) {
5132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5133 }
5134 arg1 = reinterpret_cast< wxSize * >(argp1);
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 result = (int)((wxSize const *)arg1)->GetWidth();
5138 wxPyEndAllowThreads(__tstate);
5139 if (PyErr_Occurred()) SWIG_fail;
5140 }
5141 resultobj = SWIG_From_int(static_cast< int >(result));
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 wxSize *arg1 = (wxSize *) 0 ;
5151 int result;
5152 void *argp1 = 0 ;
5153 int res1 = 0 ;
5154 PyObject *swig_obj[1] ;
5155
5156 if (!args) SWIG_fail;
5157 swig_obj[0] = args;
5158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5159 if (!SWIG_IsOK(res1)) {
5160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5161 }
5162 arg1 = reinterpret_cast< wxSize * >(argp1);
5163 {
5164 PyThreadState* __tstate = wxPyBeginAllowThreads();
5165 result = (int)((wxSize const *)arg1)->GetHeight();
5166 wxPyEndAllowThreads(__tstate);
5167 if (PyErr_Occurred()) SWIG_fail;
5168 }
5169 resultobj = SWIG_From_int(static_cast< int >(result));
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxSize *arg1 = (wxSize *) 0 ;
5179 bool result;
5180 void *argp1 = 0 ;
5181 int res1 = 0 ;
5182 PyObject *swig_obj[1] ;
5183
5184 if (!args) SWIG_fail;
5185 swig_obj[0] = args;
5186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5187 if (!SWIG_IsOK(res1)) {
5188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5189 }
5190 arg1 = reinterpret_cast< wxSize * >(argp1);
5191 {
5192 PyThreadState* __tstate = wxPyBeginAllowThreads();
5193 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5194 wxPyEndAllowThreads(__tstate);
5195 if (PyErr_Occurred()) SWIG_fail;
5196 }
5197 {
5198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5199 }
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj = 0;
5208 wxSize *arg1 = (wxSize *) 0 ;
5209 wxSize *arg2 = 0 ;
5210 void *argp1 = 0 ;
5211 int res1 = 0 ;
5212 wxSize temp2 ;
5213 PyObject * obj0 = 0 ;
5214 PyObject * obj1 = 0 ;
5215 char * kwnames[] = {
5216 (char *) "self",(char *) "size", NULL
5217 };
5218
5219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5221 if (!SWIG_IsOK(res1)) {
5222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5223 }
5224 arg1 = reinterpret_cast< wxSize * >(argp1);
5225 {
5226 arg2 = &temp2;
5227 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5228 }
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 (arg1)->SetDefaults((wxSize const &)*arg2);
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 resultobj = SWIG_Py_Void();
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5243 PyObject *resultobj = 0;
5244 wxSize *arg1 = (wxSize *) 0 ;
5245 PyObject *result = 0 ;
5246 void *argp1 = 0 ;
5247 int res1 = 0 ;
5248 PyObject *swig_obj[1] ;
5249
5250 if (!args) SWIG_fail;
5251 swig_obj[0] = args;
5252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5253 if (!SWIG_IsOK(res1)) {
5254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5255 }
5256 arg1 = reinterpret_cast< wxSize * >(argp1);
5257 {
5258 PyThreadState* __tstate = wxPyBeginAllowThreads();
5259 result = (PyObject *)wxSize_Get(arg1);
5260 wxPyEndAllowThreads(__tstate);
5261 if (PyErr_Occurred()) SWIG_fail;
5262 }
5263 resultobj = result;
5264 return resultobj;
5265 fail:
5266 return NULL;
5267 }
5268
5269
5270 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5271 PyObject *obj;
5272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5273 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5274 return SWIG_Py_Void();
5275 }
5276
5277 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5278 return SWIG_Python_InitShadowInstance(args);
5279 }
5280
5281 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5282 PyObject *resultobj = 0;
5283 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5284 double arg2 ;
5285 void *argp1 = 0 ;
5286 int res1 = 0 ;
5287 double val2 ;
5288 int ecode2 = 0 ;
5289 PyObject *swig_obj[2] ;
5290
5291 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5295 }
5296 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5297 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5298 if (!SWIG_IsOK(ecode2)) {
5299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5300 }
5301 arg2 = static_cast< double >(val2);
5302 if (arg1) (arg1)->x = arg2;
5303
5304 resultobj = SWIG_Py_Void();
5305 return resultobj;
5306 fail:
5307 return NULL;
5308 }
5309
5310
5311 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 PyObject *resultobj = 0;
5313 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5314 double result;
5315 void *argp1 = 0 ;
5316 int res1 = 0 ;
5317 PyObject *swig_obj[1] ;
5318
5319 if (!args) SWIG_fail;
5320 swig_obj[0] = args;
5321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5324 }
5325 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5326 result = (double) ((arg1)->x);
5327 resultobj = SWIG_From_double(static_cast< double >(result));
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 double arg2 ;
5338 void *argp1 = 0 ;
5339 int res1 = 0 ;
5340 double val2 ;
5341 int ecode2 = 0 ;
5342 PyObject *swig_obj[2] ;
5343
5344 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5346 if (!SWIG_IsOK(res1)) {
5347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5348 }
5349 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5350 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5351 if (!SWIG_IsOK(ecode2)) {
5352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5353 }
5354 arg2 = static_cast< double >(val2);
5355 if (arg1) (arg1)->y = arg2;
5356
5357 resultobj = SWIG_Py_Void();
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5365 PyObject *resultobj = 0;
5366 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5367 double result;
5368 void *argp1 = 0 ;
5369 int res1 = 0 ;
5370 PyObject *swig_obj[1] ;
5371
5372 if (!args) SWIG_fail;
5373 swig_obj[0] = args;
5374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5375 if (!SWIG_IsOK(res1)) {
5376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5377 }
5378 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5379 result = (double) ((arg1)->y);
5380 resultobj = SWIG_From_double(static_cast< double >(result));
5381 return resultobj;
5382 fail:
5383 return NULL;
5384 }
5385
5386
5387 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5388 PyObject *resultobj = 0;
5389 double arg1 = (double) 0.0 ;
5390 double arg2 = (double) 0.0 ;
5391 wxRealPoint *result = 0 ;
5392 double val1 ;
5393 int ecode1 = 0 ;
5394 double val2 ;
5395 int ecode2 = 0 ;
5396 PyObject * obj0 = 0 ;
5397 PyObject * obj1 = 0 ;
5398 char * kwnames[] = {
5399 (char *) "x",(char *) "y", NULL
5400 };
5401
5402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5403 if (obj0) {
5404 ecode1 = SWIG_AsVal_double(obj0, &val1);
5405 if (!SWIG_IsOK(ecode1)) {
5406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5407 }
5408 arg1 = static_cast< double >(val1);
5409 }
5410 if (obj1) {
5411 ecode2 = SWIG_AsVal_double(obj1, &val2);
5412 if (!SWIG_IsOK(ecode2)) {
5413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5414 }
5415 arg2 = static_cast< double >(val2);
5416 }
5417 {
5418 PyThreadState* __tstate = wxPyBeginAllowThreads();
5419 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5424 return resultobj;
5425 fail:
5426 return NULL;
5427 }
5428
5429
5430 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5431 PyObject *resultobj = 0;
5432 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5433 void *argp1 = 0 ;
5434 int res1 = 0 ;
5435 PyObject *swig_obj[1] ;
5436
5437 if (!args) SWIG_fail;
5438 swig_obj[0] = args;
5439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5440 if (!SWIG_IsOK(res1)) {
5441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5442 }
5443 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5444 {
5445 PyThreadState* __tstate = wxPyBeginAllowThreads();
5446 delete arg1;
5447
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 resultobj = SWIG_Py_Void();
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5459 PyObject *resultobj = 0;
5460 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5461 PyObject *arg2 = (PyObject *) 0 ;
5462 bool result;
5463 void *argp1 = 0 ;
5464 int res1 = 0 ;
5465 PyObject * obj0 = 0 ;
5466 PyObject * obj1 = 0 ;
5467 char * kwnames[] = {
5468 (char *) "self",(char *) "other", NULL
5469 };
5470
5471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5473 if (!SWIG_IsOK(res1)) {
5474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5475 }
5476 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5477 arg2 = obj1;
5478 {
5479 result = (bool)wxRealPoint___eq__(arg1,arg2);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 {
5483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5484 }
5485 return resultobj;
5486 fail:
5487 return NULL;
5488 }
5489
5490
5491 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5492 PyObject *resultobj = 0;
5493 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5494 PyObject *arg2 = (PyObject *) 0 ;
5495 bool result;
5496 void *argp1 = 0 ;
5497 int res1 = 0 ;
5498 PyObject * obj0 = 0 ;
5499 PyObject * obj1 = 0 ;
5500 char * kwnames[] = {
5501 (char *) "self",(char *) "other", NULL
5502 };
5503
5504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5506 if (!SWIG_IsOK(res1)) {
5507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5508 }
5509 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5510 arg2 = obj1;
5511 {
5512 result = (bool)wxRealPoint___ne__(arg1,arg2);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5517 }
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj = 0;
5526 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5527 wxRealPoint *arg2 = 0 ;
5528 wxRealPoint result;
5529 void *argp1 = 0 ;
5530 int res1 = 0 ;
5531 wxRealPoint temp2 ;
5532 PyObject * obj0 = 0 ;
5533 PyObject * obj1 = 0 ;
5534 char * kwnames[] = {
5535 (char *) "self",(char *) "pt", NULL
5536 };
5537
5538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5540 if (!SWIG_IsOK(res1)) {
5541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5542 }
5543 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5544 {
5545 arg2 = &temp2;
5546 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5547 }
5548 {
5549 PyThreadState* __tstate = wxPyBeginAllowThreads();
5550 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5551 wxPyEndAllowThreads(__tstate);
5552 if (PyErr_Occurred()) SWIG_fail;
5553 }
5554 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5555 return resultobj;
5556 fail:
5557 return NULL;
5558 }
5559
5560
5561 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5562 PyObject *resultobj = 0;
5563 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5564 wxRealPoint *arg2 = 0 ;
5565 wxRealPoint result;
5566 void *argp1 = 0 ;
5567 int res1 = 0 ;
5568 wxRealPoint temp2 ;
5569 PyObject * obj0 = 0 ;
5570 PyObject * obj1 = 0 ;
5571 char * kwnames[] = {
5572 (char *) "self",(char *) "pt", NULL
5573 };
5574
5575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5577 if (!SWIG_IsOK(res1)) {
5578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5579 }
5580 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5581 {
5582 arg2 = &temp2;
5583 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5584 }
5585 {
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5592 return resultobj;
5593 fail:
5594 return NULL;
5595 }
5596
5597
5598 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5599 PyObject *resultobj = 0;
5600 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5601 double arg2 ;
5602 double arg3 ;
5603 void *argp1 = 0 ;
5604 int res1 = 0 ;
5605 double val2 ;
5606 int ecode2 = 0 ;
5607 double val3 ;
5608 int ecode3 = 0 ;
5609 PyObject * obj0 = 0 ;
5610 PyObject * obj1 = 0 ;
5611 PyObject * obj2 = 0 ;
5612 char * kwnames[] = {
5613 (char *) "self",(char *) "x",(char *) "y", NULL
5614 };
5615
5616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5618 if (!SWIG_IsOK(res1)) {
5619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5620 }
5621 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5622 ecode2 = SWIG_AsVal_double(obj1, &val2);
5623 if (!SWIG_IsOK(ecode2)) {
5624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5625 }
5626 arg2 = static_cast< double >(val2);
5627 ecode3 = SWIG_AsVal_double(obj2, &val3);
5628 if (!SWIG_IsOK(ecode3)) {
5629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5630 }
5631 arg3 = static_cast< double >(val3);
5632 {
5633 PyThreadState* __tstate = wxPyBeginAllowThreads();
5634 wxRealPoint_Set(arg1,arg2,arg3);
5635 wxPyEndAllowThreads(__tstate);
5636 if (PyErr_Occurred()) SWIG_fail;
5637 }
5638 resultobj = SWIG_Py_Void();
5639 return resultobj;
5640 fail:
5641 return NULL;
5642 }
5643
5644
5645 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5646 PyObject *resultobj = 0;
5647 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5648 PyObject *result = 0 ;
5649 void *argp1 = 0 ;
5650 int res1 = 0 ;
5651 PyObject *swig_obj[1] ;
5652
5653 if (!args) SWIG_fail;
5654 swig_obj[0] = args;
5655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5656 if (!SWIG_IsOK(res1)) {
5657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5658 }
5659 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5660 {
5661 PyThreadState* __tstate = wxPyBeginAllowThreads();
5662 result = (PyObject *)wxRealPoint_Get(arg1);
5663 wxPyEndAllowThreads(__tstate);
5664 if (PyErr_Occurred()) SWIG_fail;
5665 }
5666 resultobj = result;
5667 return resultobj;
5668 fail:
5669 return NULL;
5670 }
5671
5672
5673 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5674 PyObject *obj;
5675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5676 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5677 return SWIG_Py_Void();
5678 }
5679
5680 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5681 return SWIG_Python_InitShadowInstance(args);
5682 }
5683
5684 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5685 PyObject *resultobj = 0;
5686 wxPoint *arg1 = (wxPoint *) 0 ;
5687 int arg2 ;
5688 void *argp1 = 0 ;
5689 int res1 = 0 ;
5690 int val2 ;
5691 int ecode2 = 0 ;
5692 PyObject *swig_obj[2] ;
5693
5694 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5696 if (!SWIG_IsOK(res1)) {
5697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5698 }
5699 arg1 = reinterpret_cast< wxPoint * >(argp1);
5700 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5701 if (!SWIG_IsOK(ecode2)) {
5702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5703 }
5704 arg2 = static_cast< int >(val2);
5705 if (arg1) (arg1)->x = arg2;
5706
5707 resultobj = SWIG_Py_Void();
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5715 PyObject *resultobj = 0;
5716 wxPoint *arg1 = (wxPoint *) 0 ;
5717 int result;
5718 void *argp1 = 0 ;
5719 int res1 = 0 ;
5720 PyObject *swig_obj[1] ;
5721
5722 if (!args) SWIG_fail;
5723 swig_obj[0] = args;
5724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5725 if (!SWIG_IsOK(res1)) {
5726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5727 }
5728 arg1 = reinterpret_cast< wxPoint * >(argp1);
5729 result = (int) ((arg1)->x);
5730 resultobj = SWIG_From_int(static_cast< int >(result));
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5738 PyObject *resultobj = 0;
5739 wxPoint *arg1 = (wxPoint *) 0 ;
5740 int arg2 ;
5741 void *argp1 = 0 ;
5742 int res1 = 0 ;
5743 int val2 ;
5744 int ecode2 = 0 ;
5745 PyObject *swig_obj[2] ;
5746
5747 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5749 if (!SWIG_IsOK(res1)) {
5750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5751 }
5752 arg1 = reinterpret_cast< wxPoint * >(argp1);
5753 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5754 if (!SWIG_IsOK(ecode2)) {
5755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5756 }
5757 arg2 = static_cast< int >(val2);
5758 if (arg1) (arg1)->y = arg2;
5759
5760 resultobj = SWIG_Py_Void();
5761 return resultobj;
5762 fail:
5763 return NULL;
5764 }
5765
5766
5767 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5768 PyObject *resultobj = 0;
5769 wxPoint *arg1 = (wxPoint *) 0 ;
5770 int result;
5771 void *argp1 = 0 ;
5772 int res1 = 0 ;
5773 PyObject *swig_obj[1] ;
5774
5775 if (!args) SWIG_fail;
5776 swig_obj[0] = args;
5777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5778 if (!SWIG_IsOK(res1)) {
5779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5780 }
5781 arg1 = reinterpret_cast< wxPoint * >(argp1);
5782 result = (int) ((arg1)->y);
5783 resultobj = SWIG_From_int(static_cast< int >(result));
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj = 0;
5792 int arg1 = (int) 0 ;
5793 int arg2 = (int) 0 ;
5794 wxPoint *result = 0 ;
5795 int val1 ;
5796 int ecode1 = 0 ;
5797 int val2 ;
5798 int ecode2 = 0 ;
5799 PyObject * obj0 = 0 ;
5800 PyObject * obj1 = 0 ;
5801 char * kwnames[] = {
5802 (char *) "x",(char *) "y", NULL
5803 };
5804
5805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5806 if (obj0) {
5807 ecode1 = SWIG_AsVal_int(obj0, &val1);
5808 if (!SWIG_IsOK(ecode1)) {
5809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5810 }
5811 arg1 = static_cast< int >(val1);
5812 }
5813 if (obj1) {
5814 ecode2 = SWIG_AsVal_int(obj1, &val2);
5815 if (!SWIG_IsOK(ecode2)) {
5816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5817 }
5818 arg2 = static_cast< int >(val2);
5819 }
5820 {
5821 PyThreadState* __tstate = wxPyBeginAllowThreads();
5822 result = (wxPoint *)new wxPoint(arg1,arg2);
5823 wxPyEndAllowThreads(__tstate);
5824 if (PyErr_Occurred()) SWIG_fail;
5825 }
5826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5834 PyObject *resultobj = 0;
5835 wxPoint *arg1 = (wxPoint *) 0 ;
5836 void *argp1 = 0 ;
5837 int res1 = 0 ;
5838 PyObject *swig_obj[1] ;
5839
5840 if (!args) SWIG_fail;
5841 swig_obj[0] = args;
5842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5843 if (!SWIG_IsOK(res1)) {
5844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5845 }
5846 arg1 = reinterpret_cast< wxPoint * >(argp1);
5847 {
5848 PyThreadState* __tstate = wxPyBeginAllowThreads();
5849 delete arg1;
5850
5851 wxPyEndAllowThreads(__tstate);
5852 if (PyErr_Occurred()) SWIG_fail;
5853 }
5854 resultobj = SWIG_Py_Void();
5855 return resultobj;
5856 fail:
5857 return NULL;
5858 }
5859
5860
5861 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5862 PyObject *resultobj = 0;
5863 wxPoint *arg1 = (wxPoint *) 0 ;
5864 PyObject *arg2 = (PyObject *) 0 ;
5865 bool result;
5866 void *argp1 = 0 ;
5867 int res1 = 0 ;
5868 PyObject * obj0 = 0 ;
5869 PyObject * obj1 = 0 ;
5870 char * kwnames[] = {
5871 (char *) "self",(char *) "other", NULL
5872 };
5873
5874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5876 if (!SWIG_IsOK(res1)) {
5877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5878 }
5879 arg1 = reinterpret_cast< wxPoint * >(argp1);
5880 arg2 = obj1;
5881 {
5882 result = (bool)wxPoint___eq__(arg1,arg2);
5883 if (PyErr_Occurred()) SWIG_fail;
5884 }
5885 {
5886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5887 }
5888 return resultobj;
5889 fail:
5890 return NULL;
5891 }
5892
5893
5894 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5895 PyObject *resultobj = 0;
5896 wxPoint *arg1 = (wxPoint *) 0 ;
5897 PyObject *arg2 = (PyObject *) 0 ;
5898 bool result;
5899 void *argp1 = 0 ;
5900 int res1 = 0 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char * kwnames[] = {
5904 (char *) "self",(char *) "other", NULL
5905 };
5906
5907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5909 if (!SWIG_IsOK(res1)) {
5910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5911 }
5912 arg1 = reinterpret_cast< wxPoint * >(argp1);
5913 arg2 = obj1;
5914 {
5915 result = (bool)wxPoint___ne__(arg1,arg2);
5916 if (PyErr_Occurred()) SWIG_fail;
5917 }
5918 {
5919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5920 }
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj = 0;
5929 wxPoint *arg1 = (wxPoint *) 0 ;
5930 wxPoint *arg2 = 0 ;
5931 wxPoint result;
5932 void *argp1 = 0 ;
5933 int res1 = 0 ;
5934 wxPoint temp2 ;
5935 PyObject * obj0 = 0 ;
5936 PyObject * obj1 = 0 ;
5937 char * kwnames[] = {
5938 (char *) "self",(char *) "pt", NULL
5939 };
5940
5941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5943 if (!SWIG_IsOK(res1)) {
5944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5945 }
5946 arg1 = reinterpret_cast< wxPoint * >(argp1);
5947 {
5948 arg2 = &temp2;
5949 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5950 }
5951 {
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 result = (arg1)->operator +((wxPoint const &)*arg2);
5954 wxPyEndAllowThreads(__tstate);
5955 if (PyErr_Occurred()) SWIG_fail;
5956 }
5957 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj = 0;
5966 wxPoint *arg1 = (wxPoint *) 0 ;
5967 wxPoint *arg2 = 0 ;
5968 wxPoint result;
5969 void *argp1 = 0 ;
5970 int res1 = 0 ;
5971 wxPoint temp2 ;
5972 PyObject * obj0 = 0 ;
5973 PyObject * obj1 = 0 ;
5974 char * kwnames[] = {
5975 (char *) "self",(char *) "pt", NULL
5976 };
5977
5978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5980 if (!SWIG_IsOK(res1)) {
5981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5982 }
5983 arg1 = reinterpret_cast< wxPoint * >(argp1);
5984 {
5985 arg2 = &temp2;
5986 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5987 }
5988 {
5989 PyThreadState* __tstate = wxPyBeginAllowThreads();
5990 result = (arg1)->operator -((wxPoint const &)*arg2);
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 wxPoint *arg2 = 0 ;
6005 wxPoint *result = 0 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 wxPoint temp2 ;
6009 PyObject * obj0 = 0 ;
6010 PyObject * obj1 = 0 ;
6011 char * kwnames[] = {
6012 (char *) "self",(char *) "pt", NULL
6013 };
6014
6015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6017 if (!SWIG_IsOK(res1)) {
6018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6019 }
6020 arg1 = reinterpret_cast< wxPoint * >(argp1);
6021 {
6022 arg2 = &temp2;
6023 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6024 }
6025 {
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 {
6028 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6029 result = (wxPoint *) &_result_ref;
6030 }
6031 wxPyEndAllowThreads(__tstate);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6042 PyObject *resultobj = 0;
6043 wxPoint *arg1 = (wxPoint *) 0 ;
6044 wxPoint *arg2 = 0 ;
6045 wxPoint *result = 0 ;
6046 void *argp1 = 0 ;
6047 int res1 = 0 ;
6048 wxPoint temp2 ;
6049 PyObject * obj0 = 0 ;
6050 PyObject * obj1 = 0 ;
6051 char * kwnames[] = {
6052 (char *) "self",(char *) "pt", NULL
6053 };
6054
6055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6057 if (!SWIG_IsOK(res1)) {
6058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6059 }
6060 arg1 = reinterpret_cast< wxPoint * >(argp1);
6061 {
6062 arg2 = &temp2;
6063 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6064 }
6065 {
6066 PyThreadState* __tstate = wxPyBeginAllowThreads();
6067 {
6068 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6069 result = (wxPoint *) &_result_ref;
6070 }
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj = 0;
6083 wxPoint *arg1 = (wxPoint *) 0 ;
6084 long arg2 ;
6085 long arg3 ;
6086 void *argp1 = 0 ;
6087 int res1 = 0 ;
6088 long val2 ;
6089 int ecode2 = 0 ;
6090 long val3 ;
6091 int ecode3 = 0 ;
6092 PyObject * obj0 = 0 ;
6093 PyObject * obj1 = 0 ;
6094 PyObject * obj2 = 0 ;
6095 char * kwnames[] = {
6096 (char *) "self",(char *) "x",(char *) "y", NULL
6097 };
6098
6099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6101 if (!SWIG_IsOK(res1)) {
6102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6103 }
6104 arg1 = reinterpret_cast< wxPoint * >(argp1);
6105 ecode2 = SWIG_AsVal_long(obj1, &val2);
6106 if (!SWIG_IsOK(ecode2)) {
6107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6108 }
6109 arg2 = static_cast< long >(val2);
6110 ecode3 = SWIG_AsVal_long(obj2, &val3);
6111 if (!SWIG_IsOK(ecode3)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6113 }
6114 arg3 = static_cast< long >(val3);
6115 {
6116 PyThreadState* __tstate = wxPyBeginAllowThreads();
6117 wxPoint_Set(arg1,arg2,arg3);
6118 wxPyEndAllowThreads(__tstate);
6119 if (PyErr_Occurred()) SWIG_fail;
6120 }
6121 resultobj = SWIG_Py_Void();
6122 return resultobj;
6123 fail:
6124 return NULL;
6125 }
6126
6127
6128 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6129 PyObject *resultobj = 0;
6130 wxPoint *arg1 = (wxPoint *) 0 ;
6131 PyObject *result = 0 ;
6132 void *argp1 = 0 ;
6133 int res1 = 0 ;
6134 PyObject *swig_obj[1] ;
6135
6136 if (!args) SWIG_fail;
6137 swig_obj[0] = args;
6138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6139 if (!SWIG_IsOK(res1)) {
6140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6141 }
6142 arg1 = reinterpret_cast< wxPoint * >(argp1);
6143 {
6144 PyThreadState* __tstate = wxPyBeginAllowThreads();
6145 result = (PyObject *)wxPoint_Get(arg1);
6146 wxPyEndAllowThreads(__tstate);
6147 if (PyErr_Occurred()) SWIG_fail;
6148 }
6149 resultobj = result;
6150 return resultobj;
6151 fail:
6152 return NULL;
6153 }
6154
6155
6156 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6157 PyObject *obj;
6158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6159 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6160 return SWIG_Py_Void();
6161 }
6162
6163 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6164 return SWIG_Python_InitShadowInstance(args);
6165 }
6166
6167 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6168 PyObject *resultobj = 0;
6169 int arg1 = (int) 0 ;
6170 int arg2 = (int) 0 ;
6171 int arg3 = (int) 0 ;
6172 int arg4 = (int) 0 ;
6173 wxRect *result = 0 ;
6174 int val1 ;
6175 int ecode1 = 0 ;
6176 int val2 ;
6177 int ecode2 = 0 ;
6178 int val3 ;
6179 int ecode3 = 0 ;
6180 int val4 ;
6181 int ecode4 = 0 ;
6182 PyObject * obj0 = 0 ;
6183 PyObject * obj1 = 0 ;
6184 PyObject * obj2 = 0 ;
6185 PyObject * obj3 = 0 ;
6186 char * kwnames[] = {
6187 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6188 };
6189
6190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6191 if (obj0) {
6192 ecode1 = SWIG_AsVal_int(obj0, &val1);
6193 if (!SWIG_IsOK(ecode1)) {
6194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6195 }
6196 arg1 = static_cast< int >(val1);
6197 }
6198 if (obj1) {
6199 ecode2 = SWIG_AsVal_int(obj1, &val2);
6200 if (!SWIG_IsOK(ecode2)) {
6201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6202 }
6203 arg2 = static_cast< int >(val2);
6204 }
6205 if (obj2) {
6206 ecode3 = SWIG_AsVal_int(obj2, &val3);
6207 if (!SWIG_IsOK(ecode3)) {
6208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6209 }
6210 arg3 = static_cast< int >(val3);
6211 }
6212 if (obj3) {
6213 ecode4 = SWIG_AsVal_int(obj3, &val4);
6214 if (!SWIG_IsOK(ecode4)) {
6215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6216 }
6217 arg4 = static_cast< int >(val4);
6218 }
6219 {
6220 PyThreadState* __tstate = wxPyBeginAllowThreads();
6221 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6222 wxPyEndAllowThreads(__tstate);
6223 if (PyErr_Occurred()) SWIG_fail;
6224 }
6225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj = 0;
6234 wxPoint *arg1 = 0 ;
6235 wxPoint *arg2 = 0 ;
6236 wxRect *result = 0 ;
6237 wxPoint temp1 ;
6238 wxPoint temp2 ;
6239 PyObject * obj0 = 0 ;
6240 PyObject * obj1 = 0 ;
6241 char * kwnames[] = {
6242 (char *) "topLeft",(char *) "bottomRight", NULL
6243 };
6244
6245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6246 {
6247 arg1 = &temp1;
6248 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6249 }
6250 {
6251 arg2 = &temp2;
6252 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6253 }
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj = 0;
6269 wxPoint *arg1 = 0 ;
6270 wxSize *arg2 = 0 ;
6271 wxRect *result = 0 ;
6272 wxPoint temp1 ;
6273 wxSize temp2 ;
6274 PyObject * obj0 = 0 ;
6275 PyObject * obj1 = 0 ;
6276 char * kwnames[] = {
6277 (char *) "pos",(char *) "size", NULL
6278 };
6279
6280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6281 {
6282 arg1 = &temp1;
6283 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6284 }
6285 {
6286 arg2 = &temp2;
6287 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6288 }
6289 {
6290 PyThreadState* __tstate = wxPyBeginAllowThreads();
6291 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6292 wxPyEndAllowThreads(__tstate);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6296 return resultobj;
6297 fail:
6298 return NULL;
6299 }
6300
6301
6302 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj = 0;
6304 wxSize *arg1 = 0 ;
6305 wxRect *result = 0 ;
6306 wxSize temp1 ;
6307 PyObject * obj0 = 0 ;
6308 char * kwnames[] = {
6309 (char *) "size", NULL
6310 };
6311
6312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6313 {
6314 arg1 = &temp1;
6315 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6316 }
6317 {
6318 PyThreadState* __tstate = wxPyBeginAllowThreads();
6319 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6320 wxPyEndAllowThreads(__tstate);
6321 if (PyErr_Occurred()) SWIG_fail;
6322 }
6323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6324 return resultobj;
6325 fail:
6326 return NULL;
6327 }
6328
6329
6330 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6331 PyObject *resultobj = 0;
6332 wxRect *arg1 = (wxRect *) 0 ;
6333 void *argp1 = 0 ;
6334 int res1 = 0 ;
6335 PyObject *swig_obj[1] ;
6336
6337 if (!args) SWIG_fail;
6338 swig_obj[0] = args;
6339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6340 if (!SWIG_IsOK(res1)) {
6341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6342 }
6343 arg1 = reinterpret_cast< wxRect * >(argp1);
6344 {
6345 PyThreadState* __tstate = wxPyBeginAllowThreads();
6346 delete arg1;
6347
6348 wxPyEndAllowThreads(__tstate);
6349 if (PyErr_Occurred()) SWIG_fail;
6350 }
6351 resultobj = SWIG_Py_Void();
6352 return resultobj;
6353 fail:
6354 return NULL;
6355 }
6356
6357
6358 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6359 PyObject *resultobj = 0;
6360 wxRect *arg1 = (wxRect *) 0 ;
6361 int result;
6362 void *argp1 = 0 ;
6363 int res1 = 0 ;
6364 PyObject *swig_obj[1] ;
6365
6366 if (!args) SWIG_fail;
6367 swig_obj[0] = args;
6368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6369 if (!SWIG_IsOK(res1)) {
6370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6371 }
6372 arg1 = reinterpret_cast< wxRect * >(argp1);
6373 {
6374 PyThreadState* __tstate = wxPyBeginAllowThreads();
6375 result = (int)((wxRect const *)arg1)->GetX();
6376 wxPyEndAllowThreads(__tstate);
6377 if (PyErr_Occurred()) SWIG_fail;
6378 }
6379 resultobj = SWIG_From_int(static_cast< int >(result));
6380 return resultobj;
6381 fail:
6382 return NULL;
6383 }
6384
6385
6386 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6387 PyObject *resultobj = 0;
6388 wxRect *arg1 = (wxRect *) 0 ;
6389 int arg2 ;
6390 void *argp1 = 0 ;
6391 int res1 = 0 ;
6392 int val2 ;
6393 int ecode2 = 0 ;
6394 PyObject * obj0 = 0 ;
6395 PyObject * obj1 = 0 ;
6396 char * kwnames[] = {
6397 (char *) "self",(char *) "x", NULL
6398 };
6399
6400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6402 if (!SWIG_IsOK(res1)) {
6403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6404 }
6405 arg1 = reinterpret_cast< wxRect * >(argp1);
6406 ecode2 = SWIG_AsVal_int(obj1, &val2);
6407 if (!SWIG_IsOK(ecode2)) {
6408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6409 }
6410 arg2 = static_cast< int >(val2);
6411 {
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 (arg1)->SetX(arg2);
6414 wxPyEndAllowThreads(__tstate);
6415 if (PyErr_Occurred()) SWIG_fail;
6416 }
6417 resultobj = SWIG_Py_Void();
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6425 PyObject *resultobj = 0;
6426 wxRect *arg1 = (wxRect *) 0 ;
6427 int result;
6428 void *argp1 = 0 ;
6429 int res1 = 0 ;
6430 PyObject *swig_obj[1] ;
6431
6432 if (!args) SWIG_fail;
6433 swig_obj[0] = args;
6434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6435 if (!SWIG_IsOK(res1)) {
6436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6437 }
6438 arg1 = reinterpret_cast< wxRect * >(argp1);
6439 {
6440 PyThreadState* __tstate = wxPyBeginAllowThreads();
6441 result = (int)(arg1)->GetY();
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 resultobj = SWIG_From_int(static_cast< int >(result));
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6453 PyObject *resultobj = 0;
6454 wxRect *arg1 = (wxRect *) 0 ;
6455 int arg2 ;
6456 void *argp1 = 0 ;
6457 int res1 = 0 ;
6458 int val2 ;
6459 int ecode2 = 0 ;
6460 PyObject * obj0 = 0 ;
6461 PyObject * obj1 = 0 ;
6462 char * kwnames[] = {
6463 (char *) "self",(char *) "y", NULL
6464 };
6465
6466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6468 if (!SWIG_IsOK(res1)) {
6469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6470 }
6471 arg1 = reinterpret_cast< wxRect * >(argp1);
6472 ecode2 = SWIG_AsVal_int(obj1, &val2);
6473 if (!SWIG_IsOK(ecode2)) {
6474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6475 }
6476 arg2 = static_cast< int >(val2);
6477 {
6478 PyThreadState* __tstate = wxPyBeginAllowThreads();
6479 (arg1)->SetY(arg2);
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_Py_Void();
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6491 PyObject *resultobj = 0;
6492 wxRect *arg1 = (wxRect *) 0 ;
6493 int result;
6494 void *argp1 = 0 ;
6495 int res1 = 0 ;
6496 PyObject *swig_obj[1] ;
6497
6498 if (!args) SWIG_fail;
6499 swig_obj[0] = args;
6500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6501 if (!SWIG_IsOK(res1)) {
6502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6503 }
6504 arg1 = reinterpret_cast< wxRect * >(argp1);
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (int)((wxRect const *)arg1)->GetWidth();
6508 wxPyEndAllowThreads(__tstate);
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 resultobj = SWIG_From_int(static_cast< int >(result));
6512 return resultobj;
6513 fail:
6514 return NULL;
6515 }
6516
6517
6518 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6519 PyObject *resultobj = 0;
6520 wxRect *arg1 = (wxRect *) 0 ;
6521 int arg2 ;
6522 void *argp1 = 0 ;
6523 int res1 = 0 ;
6524 int val2 ;
6525 int ecode2 = 0 ;
6526 PyObject * obj0 = 0 ;
6527 PyObject * obj1 = 0 ;
6528 char * kwnames[] = {
6529 (char *) "self",(char *) "w", NULL
6530 };
6531
6532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 ecode2 = SWIG_AsVal_int(obj1, &val2);
6539 if (!SWIG_IsOK(ecode2)) {
6540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6541 }
6542 arg2 = static_cast< int >(val2);
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 (arg1)->SetWidth(arg2);
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 resultobj = SWIG_Py_Void();
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6557 PyObject *resultobj = 0;
6558 wxRect *arg1 = (wxRect *) 0 ;
6559 int result;
6560 void *argp1 = 0 ;
6561 int res1 = 0 ;
6562 PyObject *swig_obj[1] ;
6563
6564 if (!args) SWIG_fail;
6565 swig_obj[0] = args;
6566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6567 if (!SWIG_IsOK(res1)) {
6568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6569 }
6570 arg1 = reinterpret_cast< wxRect * >(argp1);
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 result = (int)((wxRect const *)arg1)->GetHeight();
6574 wxPyEndAllowThreads(__tstate);
6575 if (PyErr_Occurred()) SWIG_fail;
6576 }
6577 resultobj = SWIG_From_int(static_cast< int >(result));
6578 return resultobj;
6579 fail:
6580 return NULL;
6581 }
6582
6583
6584 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6585 PyObject *resultobj = 0;
6586 wxRect *arg1 = (wxRect *) 0 ;
6587 int arg2 ;
6588 void *argp1 = 0 ;
6589 int res1 = 0 ;
6590 int val2 ;
6591 int ecode2 = 0 ;
6592 PyObject * obj0 = 0 ;
6593 PyObject * obj1 = 0 ;
6594 char * kwnames[] = {
6595 (char *) "self",(char *) "h", NULL
6596 };
6597
6598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6600 if (!SWIG_IsOK(res1)) {
6601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6602 }
6603 arg1 = reinterpret_cast< wxRect * >(argp1);
6604 ecode2 = SWIG_AsVal_int(obj1, &val2);
6605 if (!SWIG_IsOK(ecode2)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6607 }
6608 arg2 = static_cast< int >(val2);
6609 {
6610 PyThreadState* __tstate = wxPyBeginAllowThreads();
6611 (arg1)->SetHeight(arg2);
6612 wxPyEndAllowThreads(__tstate);
6613 if (PyErr_Occurred()) SWIG_fail;
6614 }
6615 resultobj = SWIG_Py_Void();
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6623 PyObject *resultobj = 0;
6624 wxRect *arg1 = (wxRect *) 0 ;
6625 wxPoint result;
6626 void *argp1 = 0 ;
6627 int res1 = 0 ;
6628 PyObject *swig_obj[1] ;
6629
6630 if (!args) SWIG_fail;
6631 swig_obj[0] = args;
6632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6633 if (!SWIG_IsOK(res1)) {
6634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6635 }
6636 arg1 = reinterpret_cast< wxRect * >(argp1);
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = ((wxRect const *)arg1)->GetPosition();
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj = 0;
6652 wxRect *arg1 = (wxRect *) 0 ;
6653 wxPoint *arg2 = 0 ;
6654 void *argp1 = 0 ;
6655 int res1 = 0 ;
6656 wxPoint temp2 ;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 char * kwnames[] = {
6660 (char *) "self",(char *) "p", NULL
6661 };
6662
6663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6665 if (!SWIG_IsOK(res1)) {
6666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6667 }
6668 arg1 = reinterpret_cast< wxRect * >(argp1);
6669 {
6670 arg2 = &temp2;
6671 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6672 }
6673 {
6674 PyThreadState* __tstate = wxPyBeginAllowThreads();
6675 (arg1)->SetPosition((wxPoint const &)*arg2);
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 resultobj = SWIG_Py_Void();
6680 return resultobj;
6681 fail:
6682 return NULL;
6683 }
6684
6685
6686 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6687 PyObject *resultobj = 0;
6688 wxRect *arg1 = (wxRect *) 0 ;
6689 wxSize result;
6690 void *argp1 = 0 ;
6691 int res1 = 0 ;
6692 PyObject *swig_obj[1] ;
6693
6694 if (!args) SWIG_fail;
6695 swig_obj[0] = args;
6696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6697 if (!SWIG_IsOK(res1)) {
6698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6699 }
6700 arg1 = reinterpret_cast< wxRect * >(argp1);
6701 {
6702 PyThreadState* __tstate = wxPyBeginAllowThreads();
6703 result = ((wxRect const *)arg1)->GetSize();
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj = 0;
6716 wxRect *arg1 = (wxRect *) 0 ;
6717 wxSize *arg2 = 0 ;
6718 void *argp1 = 0 ;
6719 int res1 = 0 ;
6720 wxSize temp2 ;
6721 PyObject * obj0 = 0 ;
6722 PyObject * obj1 = 0 ;
6723 char * kwnames[] = {
6724 (char *) "self",(char *) "s", NULL
6725 };
6726
6727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6729 if (!SWIG_IsOK(res1)) {
6730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6731 }
6732 arg1 = reinterpret_cast< wxRect * >(argp1);
6733 {
6734 arg2 = &temp2;
6735 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6736 }
6737 {
6738 PyThreadState* __tstate = wxPyBeginAllowThreads();
6739 (arg1)->SetSize((wxSize const &)*arg2);
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 resultobj = SWIG_Py_Void();
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751 PyObject *resultobj = 0;
6752 wxRect *arg1 = (wxRect *) 0 ;
6753 bool result;
6754 void *argp1 = 0 ;
6755 int res1 = 0 ;
6756 PyObject *swig_obj[1] ;
6757
6758 if (!args) SWIG_fail;
6759 swig_obj[0] = args;
6760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6761 if (!SWIG_IsOK(res1)) {
6762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6763 }
6764 arg1 = reinterpret_cast< wxRect * >(argp1);
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (bool)((wxRect const *)arg1)->IsEmpty();
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 {
6772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6773 }
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6781 PyObject *resultobj = 0;
6782 wxRect *arg1 = (wxRect *) 0 ;
6783 wxPoint result;
6784 void *argp1 = 0 ;
6785 int res1 = 0 ;
6786 PyObject *swig_obj[1] ;
6787
6788 if (!args) SWIG_fail;
6789 swig_obj[0] = args;
6790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6793 }
6794 arg1 = reinterpret_cast< wxRect * >(argp1);
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 result = ((wxRect const *)arg1)->GetTopLeft();
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6802 return resultobj;
6803 fail:
6804 return NULL;
6805 }
6806
6807
6808 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6809 PyObject *resultobj = 0;
6810 wxRect *arg1 = (wxRect *) 0 ;
6811 wxPoint *arg2 = 0 ;
6812 void *argp1 = 0 ;
6813 int res1 = 0 ;
6814 wxPoint temp2 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 char * kwnames[] = {
6818 (char *) "self",(char *) "p", NULL
6819 };
6820
6821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 {
6828 arg2 = &temp2;
6829 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6830 }
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_Py_Void();
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 wxPoint result;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject *swig_obj[1] ;
6851
6852 if (!args) SWIG_fail;
6853 swig_obj[0] = args;
6854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 PyThreadState* __tstate = wxPyBeginAllowThreads();
6861 result = ((wxRect const *)arg1)->GetBottomRight();
6862 wxPyEndAllowThreads(__tstate);
6863 if (PyErr_Occurred()) SWIG_fail;
6864 }
6865 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6866 return resultobj;
6867 fail:
6868 return NULL;
6869 }
6870
6871
6872 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6873 PyObject *resultobj = 0;
6874 wxRect *arg1 = (wxRect *) 0 ;
6875 wxPoint *arg2 = 0 ;
6876 void *argp1 = 0 ;
6877 int res1 = 0 ;
6878 wxPoint temp2 ;
6879 PyObject * obj0 = 0 ;
6880 PyObject * obj1 = 0 ;
6881 char * kwnames[] = {
6882 (char *) "self",(char *) "p", NULL
6883 };
6884
6885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6887 if (!SWIG_IsOK(res1)) {
6888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6889 }
6890 arg1 = reinterpret_cast< wxRect * >(argp1);
6891 {
6892 arg2 = &temp2;
6893 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6894 }
6895 {
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 resultobj = SWIG_Py_Void();
6902 return resultobj;
6903 fail:
6904 return NULL;
6905 }
6906
6907
6908 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6909 PyObject *resultobj = 0;
6910 wxRect *arg1 = (wxRect *) 0 ;
6911 wxPoint result;
6912 void *argp1 = 0 ;
6913 int res1 = 0 ;
6914 PyObject *swig_obj[1] ;
6915
6916 if (!args) SWIG_fail;
6917 swig_obj[0] = args;
6918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6919 if (!SWIG_IsOK(res1)) {
6920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6921 }
6922 arg1 = reinterpret_cast< wxRect * >(argp1);
6923 {
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 result = ((wxRect const *)arg1)->GetTopRight();
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6937 PyObject *resultobj = 0;
6938 wxRect *arg1 = (wxRect *) 0 ;
6939 wxPoint *arg2 = 0 ;
6940 void *argp1 = 0 ;
6941 int res1 = 0 ;
6942 wxPoint temp2 ;
6943 PyObject * obj0 = 0 ;
6944 PyObject * obj1 = 0 ;
6945 char * kwnames[] = {
6946 (char *) "self",(char *) "p", NULL
6947 };
6948
6949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6951 if (!SWIG_IsOK(res1)) {
6952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6953 }
6954 arg1 = reinterpret_cast< wxRect * >(argp1);
6955 {
6956 arg2 = &temp2;
6957 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6958 }
6959 {
6960 PyThreadState* __tstate = wxPyBeginAllowThreads();
6961 (arg1)->SetTopRight((wxPoint const &)*arg2);
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_Py_Void();
6966 return resultobj;
6967 fail:
6968 return NULL;
6969 }
6970
6971
6972 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6973 PyObject *resultobj = 0;
6974 wxRect *arg1 = (wxRect *) 0 ;
6975 wxPoint result;
6976 void *argp1 = 0 ;
6977 int res1 = 0 ;
6978 PyObject *swig_obj[1] ;
6979
6980 if (!args) SWIG_fail;
6981 swig_obj[0] = args;
6982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6983 if (!SWIG_IsOK(res1)) {
6984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6985 }
6986 arg1 = reinterpret_cast< wxRect * >(argp1);
6987 {
6988 PyThreadState* __tstate = wxPyBeginAllowThreads();
6989 result = ((wxRect const *)arg1)->GetBottomLeft();
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj = 0;
7002 wxRect *arg1 = (wxRect *) 0 ;
7003 wxPoint *arg2 = 0 ;
7004 void *argp1 = 0 ;
7005 int res1 = 0 ;
7006 wxPoint temp2 ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 char * kwnames[] = {
7010 (char *) "self",(char *) "p", NULL
7011 };
7012
7013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7015 if (!SWIG_IsOK(res1)) {
7016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7017 }
7018 arg1 = reinterpret_cast< wxRect * >(argp1);
7019 {
7020 arg2 = &temp2;
7021 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7022 }
7023 {
7024 PyThreadState* __tstate = wxPyBeginAllowThreads();
7025 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7026 wxPyEndAllowThreads(__tstate);
7027 if (PyErr_Occurred()) SWIG_fail;
7028 }
7029 resultobj = SWIG_Py_Void();
7030 return resultobj;
7031 fail:
7032 return NULL;
7033 }
7034
7035
7036 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7037 PyObject *resultobj = 0;
7038 wxRect *arg1 = (wxRect *) 0 ;
7039 int result;
7040 void *argp1 = 0 ;
7041 int res1 = 0 ;
7042 PyObject *swig_obj[1] ;
7043
7044 if (!args) SWIG_fail;
7045 swig_obj[0] = args;
7046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7047 if (!SWIG_IsOK(res1)) {
7048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7049 }
7050 arg1 = reinterpret_cast< wxRect * >(argp1);
7051 {
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 result = (int)((wxRect const *)arg1)->GetLeft();
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_From_int(static_cast< int >(result));
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7065 PyObject *resultobj = 0;
7066 wxRect *arg1 = (wxRect *) 0 ;
7067 int result;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 PyObject *swig_obj[1] ;
7071
7072 if (!args) SWIG_fail;
7073 swig_obj[0] = args;
7074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7075 if (!SWIG_IsOK(res1)) {
7076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7077 }
7078 arg1 = reinterpret_cast< wxRect * >(argp1);
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 result = (int)((wxRect const *)arg1)->GetTop();
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_From_int(static_cast< int >(result));
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7093 PyObject *resultobj = 0;
7094 wxRect *arg1 = (wxRect *) 0 ;
7095 int result;
7096 void *argp1 = 0 ;
7097 int res1 = 0 ;
7098 PyObject *swig_obj[1] ;
7099
7100 if (!args) SWIG_fail;
7101 swig_obj[0] = args;
7102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7103 if (!SWIG_IsOK(res1)) {
7104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7105 }
7106 arg1 = reinterpret_cast< wxRect * >(argp1);
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 result = (int)((wxRect const *)arg1)->GetBottom();
7110 wxPyEndAllowThreads(__tstate);
7111 if (PyErr_Occurred()) SWIG_fail;
7112 }
7113 resultobj = SWIG_From_int(static_cast< int >(result));
7114 return resultobj;
7115 fail:
7116 return NULL;
7117 }
7118
7119
7120 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7121 PyObject *resultobj = 0;
7122 wxRect *arg1 = (wxRect *) 0 ;
7123 int result;
7124 void *argp1 = 0 ;
7125 int res1 = 0 ;
7126 PyObject *swig_obj[1] ;
7127
7128 if (!args) SWIG_fail;
7129 swig_obj[0] = args;
7130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7131 if (!SWIG_IsOK(res1)) {
7132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7133 }
7134 arg1 = reinterpret_cast< wxRect * >(argp1);
7135 {
7136 PyThreadState* __tstate = wxPyBeginAllowThreads();
7137 result = (int)((wxRect const *)arg1)->GetRight();
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 resultobj = SWIG_From_int(static_cast< int >(result));
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj = 0;
7150 wxRect *arg1 = (wxRect *) 0 ;
7151 int arg2 ;
7152 void *argp1 = 0 ;
7153 int res1 = 0 ;
7154 int val2 ;
7155 int ecode2 = 0 ;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "left", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 {
7174 PyThreadState* __tstate = wxPyBeginAllowThreads();
7175 (arg1)->SetLeft(arg2);
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 resultobj = SWIG_Py_Void();
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj = 0;
7188 wxRect *arg1 = (wxRect *) 0 ;
7189 int arg2 ;
7190 void *argp1 = 0 ;
7191 int res1 = 0 ;
7192 int val2 ;
7193 int ecode2 = 0 ;
7194 PyObject * obj0 = 0 ;
7195 PyObject * obj1 = 0 ;
7196 char * kwnames[] = {
7197 (char *) "self",(char *) "right", NULL
7198 };
7199
7200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7202 if (!SWIG_IsOK(res1)) {
7203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7204 }
7205 arg1 = reinterpret_cast< wxRect * >(argp1);
7206 ecode2 = SWIG_AsVal_int(obj1, &val2);
7207 if (!SWIG_IsOK(ecode2)) {
7208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7209 }
7210 arg2 = static_cast< int >(val2);
7211 {
7212 PyThreadState* __tstate = wxPyBeginAllowThreads();
7213 (arg1)->SetRight(arg2);
7214 wxPyEndAllowThreads(__tstate);
7215 if (PyErr_Occurred()) SWIG_fail;
7216 }
7217 resultobj = SWIG_Py_Void();
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7225 PyObject *resultobj = 0;
7226 wxRect *arg1 = (wxRect *) 0 ;
7227 int arg2 ;
7228 void *argp1 = 0 ;
7229 int res1 = 0 ;
7230 int val2 ;
7231 int ecode2 = 0 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "self",(char *) "top", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7242 }
7243 arg1 = reinterpret_cast< wxRect * >(argp1);
7244 ecode2 = SWIG_AsVal_int(obj1, &val2);
7245 if (!SWIG_IsOK(ecode2)) {
7246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7247 }
7248 arg2 = static_cast< int >(val2);
7249 {
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 (arg1)->SetTop(arg2);
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 resultobj = SWIG_Py_Void();
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7263 PyObject *resultobj = 0;
7264 wxRect *arg1 = (wxRect *) 0 ;
7265 int arg2 ;
7266 void *argp1 = 0 ;
7267 int res1 = 0 ;
7268 int val2 ;
7269 int ecode2 = 0 ;
7270 PyObject * obj0 = 0 ;
7271 PyObject * obj1 = 0 ;
7272 char * kwnames[] = {
7273 (char *) "self",(char *) "bottom", NULL
7274 };
7275
7276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7278 if (!SWIG_IsOK(res1)) {
7279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7280 }
7281 arg1 = reinterpret_cast< wxRect * >(argp1);
7282 ecode2 = SWIG_AsVal_int(obj1, &val2);
7283 if (!SWIG_IsOK(ecode2)) {
7284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7285 }
7286 arg2 = static_cast< int >(val2);
7287 {
7288 PyThreadState* __tstate = wxPyBeginAllowThreads();
7289 (arg1)->SetBottom(arg2);
7290 wxPyEndAllowThreads(__tstate);
7291 if (PyErr_Occurred()) SWIG_fail;
7292 }
7293 resultobj = SWIG_Py_Void();
7294 return resultobj;
7295 fail:
7296 return NULL;
7297 }
7298
7299
7300 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj = 0;
7302 wxRect *arg1 = (wxRect *) 0 ;
7303 int arg2 ;
7304 int arg3 ;
7305 wxRect *result = 0 ;
7306 void *argp1 = 0 ;
7307 int res1 = 0 ;
7308 int val2 ;
7309 int ecode2 = 0 ;
7310 int val3 ;
7311 int ecode3 = 0 ;
7312 PyObject * obj0 = 0 ;
7313 PyObject * obj1 = 0 ;
7314 PyObject * obj2 = 0 ;
7315 char * kwnames[] = {
7316 (char *) "self",(char *) "dx",(char *) "dy", NULL
7317 };
7318
7319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7321 if (!SWIG_IsOK(res1)) {
7322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7323 }
7324 arg1 = reinterpret_cast< wxRect * >(argp1);
7325 ecode2 = SWIG_AsVal_int(obj1, &val2);
7326 if (!SWIG_IsOK(ecode2)) {
7327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7328 }
7329 arg2 = static_cast< int >(val2);
7330 ecode3 = SWIG_AsVal_int(obj2, &val3);
7331 if (!SWIG_IsOK(ecode3)) {
7332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7333 }
7334 arg3 = static_cast< int >(val3);
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 {
7338 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7339 result = (wxRect *) &_result_ref;
7340 }
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 int arg2 ;
7355 int arg3 ;
7356 wxRect *result = 0 ;
7357 void *argp1 = 0 ;
7358 int res1 = 0 ;
7359 int val2 ;
7360 int ecode2 = 0 ;
7361 int val3 ;
7362 int ecode3 = 0 ;
7363 PyObject * obj0 = 0 ;
7364 PyObject * obj1 = 0 ;
7365 PyObject * obj2 = 0 ;
7366 char * kwnames[] = {
7367 (char *) "self",(char *) "dx",(char *) "dy", NULL
7368 };
7369
7370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7372 if (!SWIG_IsOK(res1)) {
7373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7374 }
7375 arg1 = reinterpret_cast< wxRect * >(argp1);
7376 ecode2 = SWIG_AsVal_int(obj1, &val2);
7377 if (!SWIG_IsOK(ecode2)) {
7378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7379 }
7380 arg2 = static_cast< int >(val2);
7381 ecode3 = SWIG_AsVal_int(obj2, &val3);
7382 if (!SWIG_IsOK(ecode3)) {
7383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7384 }
7385 arg3 = static_cast< int >(val3);
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 {
7389 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7390 result = (wxRect *) &_result_ref;
7391 }
7392 wxPyEndAllowThreads(__tstate);
7393 if (PyErr_Occurred()) SWIG_fail;
7394 }
7395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7396 return resultobj;
7397 fail:
7398 return NULL;
7399 }
7400
7401
7402 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7403 PyObject *resultobj = 0;
7404 wxRect *arg1 = (wxRect *) 0 ;
7405 int arg2 ;
7406 int arg3 ;
7407 void *argp1 = 0 ;
7408 int res1 = 0 ;
7409 int val2 ;
7410 int ecode2 = 0 ;
7411 int val3 ;
7412 int ecode3 = 0 ;
7413 PyObject * obj0 = 0 ;
7414 PyObject * obj1 = 0 ;
7415 PyObject * obj2 = 0 ;
7416 char * kwnames[] = {
7417 (char *) "self",(char *) "dx",(char *) "dy", NULL
7418 };
7419
7420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7422 if (!SWIG_IsOK(res1)) {
7423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7424 }
7425 arg1 = reinterpret_cast< wxRect * >(argp1);
7426 ecode2 = SWIG_AsVal_int(obj1, &val2);
7427 if (!SWIG_IsOK(ecode2)) {
7428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7429 }
7430 arg2 = static_cast< int >(val2);
7431 ecode3 = SWIG_AsVal_int(obj2, &val3);
7432 if (!SWIG_IsOK(ecode3)) {
7433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7434 }
7435 arg3 = static_cast< int >(val3);
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 (arg1)->Offset(arg2,arg3);
7439 wxPyEndAllowThreads(__tstate);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 resultobj = SWIG_Py_Void();
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj = 0;
7451 wxRect *arg1 = (wxRect *) 0 ;
7452 wxPoint *arg2 = 0 ;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 wxPoint temp2 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 char * kwnames[] = {
7459 (char *) "self",(char *) "pt", NULL
7460 };
7461
7462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7464 if (!SWIG_IsOK(res1)) {
7465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7466 }
7467 arg1 = reinterpret_cast< wxRect * >(argp1);
7468 {
7469 arg2 = &temp2;
7470 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7471 }
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 (arg1)->Offset((wxPoint const &)*arg2);
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 resultobj = SWIG_Py_Void();
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj = 0;
7487 wxRect *arg1 = (wxRect *) 0 ;
7488 wxRect *arg2 = 0 ;
7489 wxRect result;
7490 void *argp1 = 0 ;
7491 int res1 = 0 ;
7492 wxRect temp2 ;
7493 PyObject * obj0 = 0 ;
7494 PyObject * obj1 = 0 ;
7495 char * kwnames[] = {
7496 (char *) "self",(char *) "rect", NULL
7497 };
7498
7499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7503 }
7504 arg1 = reinterpret_cast< wxRect * >(argp1);
7505 {
7506 arg2 = &temp2;
7507 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7508 }
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (arg1)->Intersect((wxRect const &)*arg2);
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7516 return resultobj;
7517 fail:
7518 return NULL;
7519 }
7520
7521
7522 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7523 PyObject *resultobj = 0;
7524 wxRect *arg1 = (wxRect *) 0 ;
7525 wxRect *arg2 = 0 ;
7526 wxRect result;
7527 void *argp1 = 0 ;
7528 int res1 = 0 ;
7529 wxRect temp2 ;
7530 PyObject * obj0 = 0 ;
7531 PyObject * obj1 = 0 ;
7532 char * kwnames[] = {
7533 (char *) "self",(char *) "rect", NULL
7534 };
7535
7536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7538 if (!SWIG_IsOK(res1)) {
7539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7540 }
7541 arg1 = reinterpret_cast< wxRect * >(argp1);
7542 {
7543 arg2 = &temp2;
7544 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7545 }
7546 {
7547 PyThreadState* __tstate = wxPyBeginAllowThreads();
7548 result = (arg1)->Union((wxRect const &)*arg2);
7549 wxPyEndAllowThreads(__tstate);
7550 if (PyErr_Occurred()) SWIG_fail;
7551 }
7552 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7553 return resultobj;
7554 fail:
7555 return NULL;
7556 }
7557
7558
7559 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7560 PyObject *resultobj = 0;
7561 wxRect *arg1 = (wxRect *) 0 ;
7562 wxRect *arg2 = 0 ;
7563 wxRect result;
7564 void *argp1 = 0 ;
7565 int res1 = 0 ;
7566 wxRect temp2 ;
7567 PyObject * obj0 = 0 ;
7568 PyObject * obj1 = 0 ;
7569 char * kwnames[] = {
7570 (char *) "self",(char *) "rect", NULL
7571 };
7572
7573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7575 if (!SWIG_IsOK(res1)) {
7576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7577 }
7578 arg1 = reinterpret_cast< wxRect * >(argp1);
7579 {
7580 arg2 = &temp2;
7581 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7582 }
7583 {
7584 PyThreadState* __tstate = wxPyBeginAllowThreads();
7585 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7586 wxPyEndAllowThreads(__tstate);
7587 if (PyErr_Occurred()) SWIG_fail;
7588 }
7589 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7597 PyObject *resultobj = 0;
7598 wxRect *arg1 = (wxRect *) 0 ;
7599 wxRect *arg2 = 0 ;
7600 wxRect *result = 0 ;
7601 void *argp1 = 0 ;
7602 int res1 = 0 ;
7603 wxRect temp2 ;
7604 PyObject * obj0 = 0 ;
7605 PyObject * obj1 = 0 ;
7606 char * kwnames[] = {
7607 (char *) "self",(char *) "rect", NULL
7608 };
7609
7610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7612 if (!SWIG_IsOK(res1)) {
7613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7614 }
7615 arg1 = reinterpret_cast< wxRect * >(argp1);
7616 {
7617 arg2 = &temp2;
7618 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7619 }
7620 {
7621 PyThreadState* __tstate = wxPyBeginAllowThreads();
7622 {
7623 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7624 result = (wxRect *) &_result_ref;
7625 }
7626 wxPyEndAllowThreads(__tstate);
7627 if (PyErr_Occurred()) SWIG_fail;
7628 }
7629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7637 PyObject *resultobj = 0;
7638 wxRect *arg1 = (wxRect *) 0 ;
7639 PyObject *arg2 = (PyObject *) 0 ;
7640 bool result;
7641 void *argp1 = 0 ;
7642 int res1 = 0 ;
7643 PyObject * obj0 = 0 ;
7644 PyObject * obj1 = 0 ;
7645 char * kwnames[] = {
7646 (char *) "self",(char *) "other", NULL
7647 };
7648
7649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7651 if (!SWIG_IsOK(res1)) {
7652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7653 }
7654 arg1 = reinterpret_cast< wxRect * >(argp1);
7655 arg2 = obj1;
7656 {
7657 result = (bool)wxRect___eq__(arg1,arg2);
7658 if (PyErr_Occurred()) SWIG_fail;
7659 }
7660 {
7661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7662 }
7663 return resultobj;
7664 fail:
7665 return NULL;
7666 }
7667
7668
7669 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7670 PyObject *resultobj = 0;
7671 wxRect *arg1 = (wxRect *) 0 ;
7672 PyObject *arg2 = (PyObject *) 0 ;
7673 bool result;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 PyObject * obj0 = 0 ;
7677 PyObject * obj1 = 0 ;
7678 char * kwnames[] = {
7679 (char *) "self",(char *) "other", NULL
7680 };
7681
7682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7686 }
7687 arg1 = reinterpret_cast< wxRect * >(argp1);
7688 arg2 = obj1;
7689 {
7690 result = (bool)wxRect___ne__(arg1,arg2);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 {
7694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7695 }
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7703 PyObject *resultobj = 0;
7704 wxRect *arg1 = (wxRect *) 0 ;
7705 int arg2 ;
7706 int arg3 ;
7707 bool result;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 int val3 ;
7713 int ecode3 = 0 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 PyObject * obj2 = 0 ;
7717 char * kwnames[] = {
7718 (char *) "self",(char *) "x",(char *) "y", NULL
7719 };
7720
7721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7723 if (!SWIG_IsOK(res1)) {
7724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7725 }
7726 arg1 = reinterpret_cast< wxRect * >(argp1);
7727 ecode2 = SWIG_AsVal_int(obj1, &val2);
7728 if (!SWIG_IsOK(ecode2)) {
7729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7730 }
7731 arg2 = static_cast< int >(val2);
7732 ecode3 = SWIG_AsVal_int(obj2, &val3);
7733 if (!SWIG_IsOK(ecode3)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7735 }
7736 arg3 = static_cast< int >(val3);
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 {
7744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7745 }
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7753 PyObject *resultobj = 0;
7754 wxRect *arg1 = (wxRect *) 0 ;
7755 wxPoint *arg2 = 0 ;
7756 bool result;
7757 void *argp1 = 0 ;
7758 int res1 = 0 ;
7759 wxPoint temp2 ;
7760 PyObject * obj0 = 0 ;
7761 PyObject * obj1 = 0 ;
7762 char * kwnames[] = {
7763 (char *) "self",(char *) "pt", NULL
7764 };
7765
7766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7768 if (!SWIG_IsOK(res1)) {
7769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7770 }
7771 arg1 = reinterpret_cast< wxRect * >(argp1);
7772 {
7773 arg2 = &temp2;
7774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7775 }
7776 {
7777 PyThreadState* __tstate = wxPyBeginAllowThreads();
7778 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 {
7783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7784 }
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7792 PyObject *resultobj = 0;
7793 wxRect *arg1 = (wxRect *) 0 ;
7794 wxRect *arg2 = 0 ;
7795 bool result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 wxRect temp2 ;
7799 PyObject * obj0 = 0 ;
7800 PyObject * obj1 = 0 ;
7801 char * kwnames[] = {
7802 (char *) "self",(char *) "rect", NULL
7803 };
7804
7805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7807 if (!SWIG_IsOK(res1)) {
7808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7809 }
7810 arg1 = reinterpret_cast< wxRect * >(argp1);
7811 {
7812 arg2 = &temp2;
7813 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7814 }
7815 {
7816 PyThreadState* __tstate = wxPyBeginAllowThreads();
7817 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 {
7822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7823 }
7824 return resultobj;
7825 fail:
7826 return NULL;
7827 }
7828
7829
7830 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7831 PyObject *resultobj = 0;
7832 wxRect *arg1 = (wxRect *) 0 ;
7833 wxRect *arg2 = 0 ;
7834 bool result;
7835 void *argp1 = 0 ;
7836 int res1 = 0 ;
7837 wxRect temp2 ;
7838 PyObject * obj0 = 0 ;
7839 PyObject * obj1 = 0 ;
7840 char * kwnames[] = {
7841 (char *) "self",(char *) "rect", NULL
7842 };
7843
7844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7846 if (!SWIG_IsOK(res1)) {
7847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7848 }
7849 arg1 = reinterpret_cast< wxRect * >(argp1);
7850 {
7851 arg2 = &temp2;
7852 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7853 }
7854 {
7855 PyThreadState* __tstate = wxPyBeginAllowThreads();
7856 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7857 wxPyEndAllowThreads(__tstate);
7858 if (PyErr_Occurred()) SWIG_fail;
7859 }
7860 {
7861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7862 }
7863 return resultobj;
7864 fail:
7865 return NULL;
7866 }
7867
7868
7869 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7870 PyObject *resultobj = 0;
7871 wxRect *arg1 = (wxRect *) 0 ;
7872 wxRect *arg2 = 0 ;
7873 int arg3 = (int) wxBOTH ;
7874 wxRect result;
7875 void *argp1 = 0 ;
7876 int res1 = 0 ;
7877 wxRect temp2 ;
7878 int val3 ;
7879 int ecode3 = 0 ;
7880 PyObject * obj0 = 0 ;
7881 PyObject * obj1 = 0 ;
7882 PyObject * obj2 = 0 ;
7883 char * kwnames[] = {
7884 (char *) "self",(char *) "r",(char *) "dir", NULL
7885 };
7886
7887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7889 if (!SWIG_IsOK(res1)) {
7890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7891 }
7892 arg1 = reinterpret_cast< wxRect * >(argp1);
7893 {
7894 arg2 = &temp2;
7895 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7896 }
7897 if (obj2) {
7898 ecode3 = SWIG_AsVal_int(obj2, &val3);
7899 if (!SWIG_IsOK(ecode3)) {
7900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7901 }
7902 arg3 = static_cast< int >(val3);
7903 }
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7907 wxPyEndAllowThreads(__tstate);
7908 if (PyErr_Occurred()) SWIG_fail;
7909 }
7910 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7911 return resultobj;
7912 fail:
7913 return NULL;
7914 }
7915
7916
7917 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7918 PyObject *resultobj = 0;
7919 wxRect *arg1 = (wxRect *) 0 ;
7920 int arg2 ;
7921 void *argp1 = 0 ;
7922 int res1 = 0 ;
7923 int val2 ;
7924 int ecode2 = 0 ;
7925 PyObject *swig_obj[2] ;
7926
7927 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7929 if (!SWIG_IsOK(res1)) {
7930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7931 }
7932 arg1 = reinterpret_cast< wxRect * >(argp1);
7933 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7934 if (!SWIG_IsOK(ecode2)) {
7935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7936 }
7937 arg2 = static_cast< int >(val2);
7938 if (arg1) (arg1)->x = arg2;
7939
7940 resultobj = SWIG_Py_Void();
7941 return resultobj;
7942 fail:
7943 return NULL;
7944 }
7945
7946
7947 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7948 PyObject *resultobj = 0;
7949 wxRect *arg1 = (wxRect *) 0 ;
7950 int result;
7951 void *argp1 = 0 ;
7952 int res1 = 0 ;
7953 PyObject *swig_obj[1] ;
7954
7955 if (!args) SWIG_fail;
7956 swig_obj[0] = args;
7957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7958 if (!SWIG_IsOK(res1)) {
7959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7960 }
7961 arg1 = reinterpret_cast< wxRect * >(argp1);
7962 result = (int) ((arg1)->x);
7963 resultobj = SWIG_From_int(static_cast< int >(result));
7964 return resultobj;
7965 fail:
7966 return NULL;
7967 }
7968
7969
7970 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7971 PyObject *resultobj = 0;
7972 wxRect *arg1 = (wxRect *) 0 ;
7973 int arg2 ;
7974 void *argp1 = 0 ;
7975 int res1 = 0 ;
7976 int val2 ;
7977 int ecode2 = 0 ;
7978 PyObject *swig_obj[2] ;
7979
7980 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7982 if (!SWIG_IsOK(res1)) {
7983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7984 }
7985 arg1 = reinterpret_cast< wxRect * >(argp1);
7986 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7987 if (!SWIG_IsOK(ecode2)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7989 }
7990 arg2 = static_cast< int >(val2);
7991 if (arg1) (arg1)->y = arg2;
7992
7993 resultobj = SWIG_Py_Void();
7994 return resultobj;
7995 fail:
7996 return NULL;
7997 }
7998
7999
8000 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8001 PyObject *resultobj = 0;
8002 wxRect *arg1 = (wxRect *) 0 ;
8003 int result;
8004 void *argp1 = 0 ;
8005 int res1 = 0 ;
8006 PyObject *swig_obj[1] ;
8007
8008 if (!args) SWIG_fail;
8009 swig_obj[0] = args;
8010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8011 if (!SWIG_IsOK(res1)) {
8012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8013 }
8014 arg1 = reinterpret_cast< wxRect * >(argp1);
8015 result = (int) ((arg1)->y);
8016 resultobj = SWIG_From_int(static_cast< int >(result));
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxRect *arg1 = (wxRect *) 0 ;
8026 int arg2 ;
8027 void *argp1 = 0 ;
8028 int res1 = 0 ;
8029 int val2 ;
8030 int ecode2 = 0 ;
8031 PyObject *swig_obj[2] ;
8032
8033 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8035 if (!SWIG_IsOK(res1)) {
8036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8037 }
8038 arg1 = reinterpret_cast< wxRect * >(argp1);
8039 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8040 if (!SWIG_IsOK(ecode2)) {
8041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8042 }
8043 arg2 = static_cast< int >(val2);
8044 if (arg1) (arg1)->width = arg2;
8045
8046 resultobj = SWIG_Py_Void();
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054 PyObject *resultobj = 0;
8055 wxRect *arg1 = (wxRect *) 0 ;
8056 int result;
8057 void *argp1 = 0 ;
8058 int res1 = 0 ;
8059 PyObject *swig_obj[1] ;
8060
8061 if (!args) SWIG_fail;
8062 swig_obj[0] = args;
8063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8064 if (!SWIG_IsOK(res1)) {
8065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8066 }
8067 arg1 = reinterpret_cast< wxRect * >(argp1);
8068 result = (int) ((arg1)->width);
8069 resultobj = SWIG_From_int(static_cast< int >(result));
8070 return resultobj;
8071 fail:
8072 return NULL;
8073 }
8074
8075
8076 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8077 PyObject *resultobj = 0;
8078 wxRect *arg1 = (wxRect *) 0 ;
8079 int arg2 ;
8080 void *argp1 = 0 ;
8081 int res1 = 0 ;
8082 int val2 ;
8083 int ecode2 = 0 ;
8084 PyObject *swig_obj[2] ;
8085
8086 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8088 if (!SWIG_IsOK(res1)) {
8089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8090 }
8091 arg1 = reinterpret_cast< wxRect * >(argp1);
8092 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8093 if (!SWIG_IsOK(ecode2)) {
8094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8095 }
8096 arg2 = static_cast< int >(val2);
8097 if (arg1) (arg1)->height = arg2;
8098
8099 resultobj = SWIG_Py_Void();
8100 return resultobj;
8101 fail:
8102 return NULL;
8103 }
8104
8105
8106 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8107 PyObject *resultobj = 0;
8108 wxRect *arg1 = (wxRect *) 0 ;
8109 int result;
8110 void *argp1 = 0 ;
8111 int res1 = 0 ;
8112 PyObject *swig_obj[1] ;
8113
8114 if (!args) SWIG_fail;
8115 swig_obj[0] = args;
8116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8117 if (!SWIG_IsOK(res1)) {
8118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8119 }
8120 arg1 = reinterpret_cast< wxRect * >(argp1);
8121 result = (int) ((arg1)->height);
8122 resultobj = SWIG_From_int(static_cast< int >(result));
8123 return resultobj;
8124 fail:
8125 return NULL;
8126 }
8127
8128
8129 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8130 PyObject *resultobj = 0;
8131 wxRect *arg1 = (wxRect *) 0 ;
8132 int arg2 = (int) 0 ;
8133 int arg3 = (int) 0 ;
8134 int arg4 = (int) 0 ;
8135 int arg5 = (int) 0 ;
8136 void *argp1 = 0 ;
8137 int res1 = 0 ;
8138 int val2 ;
8139 int ecode2 = 0 ;
8140 int val3 ;
8141 int ecode3 = 0 ;
8142 int val4 ;
8143 int ecode4 = 0 ;
8144 int val5 ;
8145 int ecode5 = 0 ;
8146 PyObject * obj0 = 0 ;
8147 PyObject * obj1 = 0 ;
8148 PyObject * obj2 = 0 ;
8149 PyObject * obj3 = 0 ;
8150 PyObject * obj4 = 0 ;
8151 char * kwnames[] = {
8152 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8153 };
8154
8155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8159 }
8160 arg1 = reinterpret_cast< wxRect * >(argp1);
8161 if (obj1) {
8162 ecode2 = SWIG_AsVal_int(obj1, &val2);
8163 if (!SWIG_IsOK(ecode2)) {
8164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8165 }
8166 arg2 = static_cast< int >(val2);
8167 }
8168 if (obj2) {
8169 ecode3 = SWIG_AsVal_int(obj2, &val3);
8170 if (!SWIG_IsOK(ecode3)) {
8171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8172 }
8173 arg3 = static_cast< int >(val3);
8174 }
8175 if (obj3) {
8176 ecode4 = SWIG_AsVal_int(obj3, &val4);
8177 if (!SWIG_IsOK(ecode4)) {
8178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8179 }
8180 arg4 = static_cast< int >(val4);
8181 }
8182 if (obj4) {
8183 ecode5 = SWIG_AsVal_int(obj4, &val5);
8184 if (!SWIG_IsOK(ecode5)) {
8185 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8186 }
8187 arg5 = static_cast< int >(val5);
8188 }
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_Py_Void();
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8203 PyObject *resultobj = 0;
8204 wxRect *arg1 = (wxRect *) 0 ;
8205 PyObject *result = 0 ;
8206 void *argp1 = 0 ;
8207 int res1 = 0 ;
8208 PyObject *swig_obj[1] ;
8209
8210 if (!args) SWIG_fail;
8211 swig_obj[0] = args;
8212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8213 if (!SWIG_IsOK(res1)) {
8214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8215 }
8216 arg1 = reinterpret_cast< wxRect * >(argp1);
8217 {
8218 PyThreadState* __tstate = wxPyBeginAllowThreads();
8219 result = (PyObject *)wxRect_Get(arg1);
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 resultobj = result;
8224 return resultobj;
8225 fail:
8226 return NULL;
8227 }
8228
8229
8230 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8231 PyObject *obj;
8232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8233 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8234 return SWIG_Py_Void();
8235 }
8236
8237 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8238 return SWIG_Python_InitShadowInstance(args);
8239 }
8240
8241 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8242 PyObject *resultobj = 0;
8243 wxRect *arg1 = (wxRect *) 0 ;
8244 wxRect *arg2 = (wxRect *) 0 ;
8245 PyObject *result = 0 ;
8246 void *argp1 = 0 ;
8247 int res1 = 0 ;
8248 void *argp2 = 0 ;
8249 int res2 = 0 ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "r1",(char *) "r2", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8260 }
8261 arg1 = reinterpret_cast< wxRect * >(argp1);
8262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8263 if (!SWIG_IsOK(res2)) {
8264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8265 }
8266 arg2 = reinterpret_cast< wxRect * >(argp2);
8267 {
8268 if (!wxPyCheckForApp()) SWIG_fail;
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 result = (PyObject *)wxIntersectRect(arg1,arg2);
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = result;
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj = 0;
8283 double arg1 = (double) 0.0 ;
8284 double arg2 = (double) 0.0 ;
8285 wxPoint2D *result = 0 ;
8286 double val1 ;
8287 int ecode1 = 0 ;
8288 double val2 ;
8289 int ecode2 = 0 ;
8290 PyObject * obj0 = 0 ;
8291 PyObject * obj1 = 0 ;
8292 char * kwnames[] = {
8293 (char *) "x",(char *) "y", NULL
8294 };
8295
8296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8297 if (obj0) {
8298 ecode1 = SWIG_AsVal_double(obj0, &val1);
8299 if (!SWIG_IsOK(ecode1)) {
8300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8301 }
8302 arg1 = static_cast< double >(val1);
8303 }
8304 if (obj1) {
8305 ecode2 = SWIG_AsVal_double(obj1, &val2);
8306 if (!SWIG_IsOK(ecode2)) {
8307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8308 }
8309 arg2 = static_cast< double >(val2);
8310 }
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj = 0;
8326 wxPoint2D *arg1 = 0 ;
8327 wxPoint2D *result = 0 ;
8328 wxPoint2D temp1 ;
8329 PyObject * obj0 = 0 ;
8330 char * kwnames[] = {
8331 (char *) "pt", NULL
8332 };
8333
8334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8335 {
8336 arg1 = &temp1;
8337 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8338 }
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8342 wxPyEndAllowThreads(__tstate);
8343 if (PyErr_Occurred()) SWIG_fail;
8344 }
8345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 wxPoint *arg1 = 0 ;
8355 wxPoint2D *result = 0 ;
8356 wxPoint temp1 ;
8357 PyObject * obj0 = 0 ;
8358 char * kwnames[] = {
8359 (char *) "pt", NULL
8360 };
8361
8362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8363 {
8364 arg1 = &temp1;
8365 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8366 }
8367 {
8368 PyThreadState* __tstate = wxPyBeginAllowThreads();
8369 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8370 wxPyEndAllowThreads(__tstate);
8371 if (PyErr_Occurred()) SWIG_fail;
8372 }
8373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8374 return resultobj;
8375 fail:
8376 return NULL;
8377 }
8378
8379
8380 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8381 PyObject *resultobj = 0;
8382 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8383 void *argp1 = 0 ;
8384 int res1 = 0 ;
8385 PyObject *swig_obj[1] ;
8386
8387 if (!args) SWIG_fail;
8388 swig_obj[0] = args;
8389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8390 if (!SWIG_IsOK(res1)) {
8391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8392 }
8393 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8394 {
8395 PyThreadState* __tstate = wxPyBeginAllowThreads();
8396 delete arg1;
8397
8398 wxPyEndAllowThreads(__tstate);
8399 if (PyErr_Occurred()) SWIG_fail;
8400 }
8401 resultobj = SWIG_Py_Void();
8402 return resultobj;
8403 fail:
8404 return NULL;
8405 }
8406
8407
8408 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8409 PyObject *resultobj = 0;
8410 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8411 int *arg2 = (int *) 0 ;
8412 int *arg3 = (int *) 0 ;
8413 void *argp1 = 0 ;
8414 int res1 = 0 ;
8415 int temp2 ;
8416 int res2 = SWIG_TMPOBJ ;
8417 int temp3 ;
8418 int res3 = SWIG_TMPOBJ ;
8419 PyObject *swig_obj[1] ;
8420
8421 arg2 = &temp2;
8422 arg3 = &temp3;
8423 if (!args) SWIG_fail;
8424 swig_obj[0] = args;
8425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8426 if (!SWIG_IsOK(res1)) {
8427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8428 }
8429 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8430 {
8431 PyThreadState* __tstate = wxPyBeginAllowThreads();
8432 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8433 wxPyEndAllowThreads(__tstate);
8434 if (PyErr_Occurred()) SWIG_fail;
8435 }
8436 resultobj = SWIG_Py_Void();
8437 if (SWIG_IsTmpObj(res2)) {
8438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8439 } else {
8440 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8442 }
8443 if (SWIG_IsTmpObj(res3)) {
8444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8445 } else {
8446 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8448 }
8449 return resultobj;
8450 fail:
8451 return NULL;
8452 }
8453
8454
8455 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8456 PyObject *resultobj = 0;
8457 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8458 int *arg2 = (int *) 0 ;
8459 int *arg3 = (int *) 0 ;
8460 void *argp1 = 0 ;
8461 int res1 = 0 ;
8462 int temp2 ;
8463 int res2 = SWIG_TMPOBJ ;
8464 int temp3 ;
8465 int res3 = SWIG_TMPOBJ ;
8466 PyObject *swig_obj[1] ;
8467
8468 arg2 = &temp2;
8469 arg3 = &temp3;
8470 if (!args) SWIG_fail;
8471 swig_obj[0] = args;
8472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8475 }
8476 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8480 wxPyEndAllowThreads(__tstate);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 resultobj = SWIG_Py_Void();
8484 if (SWIG_IsTmpObj(res2)) {
8485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8486 } else {
8487 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8489 }
8490 if (SWIG_IsTmpObj(res3)) {
8491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8492 } else {
8493 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8505 double result;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 PyObject *swig_obj[1] ;
8509
8510 if (!args) SWIG_fail;
8511 swig_obj[0] = args;
8512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8515 }
8516 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 resultobj = SWIG_From_double(static_cast< double >(result));
8524 return resultobj;
8525 fail:
8526 return NULL;
8527 }
8528
8529
8530 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8531 PyObject *resultobj = 0;
8532 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8533 double result;
8534 void *argp1 = 0 ;
8535 int res1 = 0 ;
8536 PyObject *swig_obj[1] ;
8537
8538 if (!args) SWIG_fail;
8539 swig_obj[0] = args;
8540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8541 if (!SWIG_IsOK(res1)) {
8542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8543 }
8544 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8548 wxPyEndAllowThreads(__tstate);
8549 if (PyErr_Occurred()) SWIG_fail;
8550 }
8551 resultobj = SWIG_From_double(static_cast< double >(result));
8552 return resultobj;
8553 fail:
8554 return NULL;
8555 }
8556
8557
8558 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8559 PyObject *resultobj = 0;
8560 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8561 double arg2 ;
8562 void *argp1 = 0 ;
8563 int res1 = 0 ;
8564 double val2 ;
8565 int ecode2 = 0 ;
8566 PyObject * obj0 = 0 ;
8567 PyObject * obj1 = 0 ;
8568 char * kwnames[] = {
8569 (char *) "self",(char *) "length", NULL
8570 };
8571
8572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8574 if (!SWIG_IsOK(res1)) {
8575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8576 }
8577 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8578 ecode2 = SWIG_AsVal_double(obj1, &val2);
8579 if (!SWIG_IsOK(ecode2)) {
8580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8581 }
8582 arg2 = static_cast< double >(val2);
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 (arg1)->SetVectorLength(arg2);
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_Py_Void();
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj = 0;
8598 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8599 double arg2 ;
8600 void *argp1 = 0 ;
8601 int res1 = 0 ;
8602 double val2 ;
8603 int ecode2 = 0 ;
8604 PyObject * obj0 = 0 ;
8605 PyObject * obj1 = 0 ;
8606 char * kwnames[] = {
8607 (char *) "self",(char *) "degrees", NULL
8608 };
8609
8610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8612 if (!SWIG_IsOK(res1)) {
8613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8614 }
8615 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8616 ecode2 = SWIG_AsVal_double(obj1, &val2);
8617 if (!SWIG_IsOK(ecode2)) {
8618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8619 }
8620 arg2 = static_cast< double >(val2);
8621 {
8622 PyThreadState* __tstate = wxPyBeginAllowThreads();
8623 (arg1)->SetVectorAngle(arg2);
8624 wxPyEndAllowThreads(__tstate);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 resultobj = SWIG_Py_Void();
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj = 0;
8636 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8637 wxPoint2D *arg2 = 0 ;
8638 double result;
8639 void *argp1 = 0 ;
8640 int res1 = 0 ;
8641 wxPoint2D temp2 ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char * kwnames[] = {
8645 (char *) "self",(char *) "pt", NULL
8646 };
8647
8648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8650 if (!SWIG_IsOK(res1)) {
8651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8652 }
8653 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8654 {
8655 arg2 = &temp2;
8656 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8657 }
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 resultobj = SWIG_From_double(static_cast< double >(result));
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj = 0;
8673 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8674 wxPoint2D *arg2 = 0 ;
8675 double result;
8676 void *argp1 = 0 ;
8677 int res1 = 0 ;
8678 wxPoint2D temp2 ;
8679 PyObject * obj0 = 0 ;
8680 PyObject * obj1 = 0 ;
8681 char * kwnames[] = {
8682 (char *) "self",(char *) "pt", NULL
8683 };
8684
8685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8687 if (!SWIG_IsOK(res1)) {
8688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8689 }
8690 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8691 {
8692 arg2 = &temp2;
8693 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8694 }
8695 {
8696 PyThreadState* __tstate = wxPyBeginAllowThreads();
8697 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8698 wxPyEndAllowThreads(__tstate);
8699 if (PyErr_Occurred()) SWIG_fail;
8700 }
8701 resultobj = SWIG_From_double(static_cast< double >(result));
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8709 PyObject *resultobj = 0;
8710 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8711 wxPoint2D *arg2 = 0 ;
8712 double result;
8713 void *argp1 = 0 ;
8714 int res1 = 0 ;
8715 wxPoint2D temp2 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 char * kwnames[] = {
8719 (char *) "self",(char *) "vec", NULL
8720 };
8721
8722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8724 if (!SWIG_IsOK(res1)) {
8725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8726 }
8727 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8728 {
8729 arg2 = &temp2;
8730 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8731 }
8732 {
8733 PyThreadState* __tstate = wxPyBeginAllowThreads();
8734 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 resultobj = SWIG_From_double(static_cast< double >(result));
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8746 PyObject *resultobj = 0;
8747 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8748 wxPoint2D *arg2 = 0 ;
8749 double result;
8750 void *argp1 = 0 ;
8751 int res1 = 0 ;
8752 wxPoint2D temp2 ;
8753 PyObject * obj0 = 0 ;
8754 PyObject * obj1 = 0 ;
8755 char * kwnames[] = {
8756 (char *) "self",(char *) "vec", NULL
8757 };
8758
8759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8761 if (!SWIG_IsOK(res1)) {
8762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8763 }
8764 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8765 {
8766 arg2 = &temp2;
8767 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8768 }
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 resultobj = SWIG_From_double(static_cast< double >(result));
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8783 PyObject *resultobj = 0;
8784 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8785 wxPoint2D result;
8786 void *argp1 = 0 ;
8787 int res1 = 0 ;
8788 PyObject *swig_obj[1] ;
8789
8790 if (!args) SWIG_fail;
8791 swig_obj[0] = args;
8792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8793 if (!SWIG_IsOK(res1)) {
8794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8795 }
8796 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8797 {
8798 PyThreadState* __tstate = wxPyBeginAllowThreads();
8799 result = (arg1)->operator -();
8800 wxPyEndAllowThreads(__tstate);
8801 if (PyErr_Occurred()) SWIG_fail;
8802 }
8803 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8804 return resultobj;
8805 fail:
8806 return NULL;
8807 }
8808
8809
8810 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8811 PyObject *resultobj = 0;
8812 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8813 wxPoint2D *arg2 = 0 ;
8814 wxPoint2D *result = 0 ;
8815 void *argp1 = 0 ;
8816 int res1 = 0 ;
8817 wxPoint2D temp2 ;
8818 PyObject * obj0 = 0 ;
8819 PyObject * obj1 = 0 ;
8820 char * kwnames[] = {
8821 (char *) "self",(char *) "pt", NULL
8822 };
8823
8824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8826 if (!SWIG_IsOK(res1)) {
8827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8828 }
8829 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8830 {
8831 arg2 = &temp2;
8832 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8833 }
8834 {
8835 PyThreadState* __tstate = wxPyBeginAllowThreads();
8836 {
8837 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8838 result = (wxPoint2D *) &_result_ref;
8839 }
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8851 PyObject *resultobj = 0;
8852 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8853 wxPoint2D *arg2 = 0 ;
8854 wxPoint2D *result = 0 ;
8855 void *argp1 = 0 ;
8856 int res1 = 0 ;
8857 wxPoint2D temp2 ;
8858 PyObject * obj0 = 0 ;
8859 PyObject * obj1 = 0 ;
8860 char * kwnames[] = {
8861 (char *) "self",(char *) "pt", NULL
8862 };
8863
8864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8866 if (!SWIG_IsOK(res1)) {
8867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8868 }
8869 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8870 {
8871 arg2 = &temp2;
8872 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8873 }
8874 {
8875 PyThreadState* __tstate = wxPyBeginAllowThreads();
8876 {
8877 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8878 result = (wxPoint2D *) &_result_ref;
8879 }
8880 wxPyEndAllowThreads(__tstate);
8881 if (PyErr_Occurred()) SWIG_fail;
8882 }
8883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8891 PyObject *resultobj = 0;
8892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8893 wxPoint2D *arg2 = 0 ;
8894 wxPoint2D *result = 0 ;
8895 void *argp1 = 0 ;
8896 int res1 = 0 ;
8897 wxPoint2D temp2 ;
8898 PyObject * obj0 = 0 ;
8899 PyObject * obj1 = 0 ;
8900 char * kwnames[] = {
8901 (char *) "self",(char *) "pt", NULL
8902 };
8903
8904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8906 if (!SWIG_IsOK(res1)) {
8907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8908 }
8909 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8910 {
8911 arg2 = &temp2;
8912 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8913 }
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 {
8917 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8918 result = (wxPoint2D *) &_result_ref;
8919 }
8920 wxPyEndAllowThreads(__tstate);
8921 if (PyErr_Occurred()) SWIG_fail;
8922 }
8923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8924 return resultobj;
8925 fail:
8926 return NULL;
8927 }
8928
8929
8930 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8931 PyObject *resultobj = 0;
8932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8933 wxPoint2D *arg2 = 0 ;
8934 wxPoint2D *result = 0 ;
8935 void *argp1 = 0 ;
8936 int res1 = 0 ;
8937 wxPoint2D temp2 ;
8938 PyObject * obj0 = 0 ;
8939 PyObject * obj1 = 0 ;
8940 char * kwnames[] = {
8941 (char *) "self",(char *) "pt", NULL
8942 };
8943
8944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8946 if (!SWIG_IsOK(res1)) {
8947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8948 }
8949 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8950 {
8951 arg2 = &temp2;
8952 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8953 }
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 {
8957 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8958 result = (wxPoint2D *) &_result_ref;
8959 }
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8971 PyObject *resultobj = 0;
8972 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8973 PyObject *arg2 = (PyObject *) 0 ;
8974 bool result;
8975 void *argp1 = 0 ;
8976 int res1 = 0 ;
8977 PyObject * obj0 = 0 ;
8978 PyObject * obj1 = 0 ;
8979 char * kwnames[] = {
8980 (char *) "self",(char *) "other", NULL
8981 };
8982
8983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8985 if (!SWIG_IsOK(res1)) {
8986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8987 }
8988 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8989 arg2 = obj1;
8990 {
8991 result = (bool)wxPoint2D___eq__(arg1,arg2);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 {
8995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8996 }
8997 return resultobj;
8998 fail:
8999 return NULL;
9000 }
9001
9002
9003 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9004 PyObject *resultobj = 0;
9005 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9006 PyObject *arg2 = (PyObject *) 0 ;
9007 bool result;
9008 void *argp1 = 0 ;
9009 int res1 = 0 ;
9010 PyObject * obj0 = 0 ;
9011 PyObject * obj1 = 0 ;
9012 char * kwnames[] = {
9013 (char *) "self",(char *) "other", NULL
9014 };
9015
9016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9018 if (!SWIG_IsOK(res1)) {
9019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9020 }
9021 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9022 arg2 = obj1;
9023 {
9024 result = (bool)wxPoint2D___ne__(arg1,arg2);
9025 if (PyErr_Occurred()) SWIG_fail;
9026 }
9027 {
9028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9029 }
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9037 PyObject *resultobj = 0;
9038 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9039 double arg2 ;
9040 void *argp1 = 0 ;
9041 int res1 = 0 ;
9042 double val2 ;
9043 int ecode2 = 0 ;
9044 PyObject *swig_obj[2] ;
9045
9046 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9048 if (!SWIG_IsOK(res1)) {
9049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9050 }
9051 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9052 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9053 if (!SWIG_IsOK(ecode2)) {
9054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9055 }
9056 arg2 = static_cast< double >(val2);
9057 if (arg1) (arg1)->m_x = arg2;
9058
9059 resultobj = SWIG_Py_Void();
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9067 PyObject *resultobj = 0;
9068 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9069 double result;
9070 void *argp1 = 0 ;
9071 int res1 = 0 ;
9072 PyObject *swig_obj[1] ;
9073
9074 if (!args) SWIG_fail;
9075 swig_obj[0] = args;
9076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9077 if (!SWIG_IsOK(res1)) {
9078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9079 }
9080 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9081 result = (double) ((arg1)->m_x);
9082 resultobj = SWIG_From_double(static_cast< double >(result));
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9090 PyObject *resultobj = 0;
9091 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9092 double arg2 ;
9093 void *argp1 = 0 ;
9094 int res1 = 0 ;
9095 double val2 ;
9096 int ecode2 = 0 ;
9097 PyObject *swig_obj[2] ;
9098
9099 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9101 if (!SWIG_IsOK(res1)) {
9102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9103 }
9104 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9105 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9106 if (!SWIG_IsOK(ecode2)) {
9107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9108 }
9109 arg2 = static_cast< double >(val2);
9110 if (arg1) (arg1)->m_y = arg2;
9111
9112 resultobj = SWIG_Py_Void();
9113 return resultobj;
9114 fail:
9115 return NULL;
9116 }
9117
9118
9119 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9120 PyObject *resultobj = 0;
9121 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9122 double result;
9123 void *argp1 = 0 ;
9124 int res1 = 0 ;
9125 PyObject *swig_obj[1] ;
9126
9127 if (!args) SWIG_fail;
9128 swig_obj[0] = args;
9129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9130 if (!SWIG_IsOK(res1)) {
9131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9132 }
9133 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9134 result = (double) ((arg1)->m_y);
9135 resultobj = SWIG_From_double(static_cast< double >(result));
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9143 PyObject *resultobj = 0;
9144 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9145 double arg2 = (double) 0 ;
9146 double arg3 = (double) 0 ;
9147 void *argp1 = 0 ;
9148 int res1 = 0 ;
9149 double val2 ;
9150 int ecode2 = 0 ;
9151 double val3 ;
9152 int ecode3 = 0 ;
9153 PyObject * obj0 = 0 ;
9154 PyObject * obj1 = 0 ;
9155 PyObject * obj2 = 0 ;
9156 char * kwnames[] = {
9157 (char *) "self",(char *) "x",(char *) "y", NULL
9158 };
9159
9160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9162 if (!SWIG_IsOK(res1)) {
9163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9164 }
9165 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9166 if (obj1) {
9167 ecode2 = SWIG_AsVal_double(obj1, &val2);
9168 if (!SWIG_IsOK(ecode2)) {
9169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9170 }
9171 arg2 = static_cast< double >(val2);
9172 }
9173 if (obj2) {
9174 ecode3 = SWIG_AsVal_double(obj2, &val3);
9175 if (!SWIG_IsOK(ecode3)) {
9176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9177 }
9178 arg3 = static_cast< double >(val3);
9179 }
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 wxPoint2D_Set(arg1,arg2,arg3);
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 resultobj = SWIG_Py_Void();
9187 return resultobj;
9188 fail:
9189 return NULL;
9190 }
9191
9192
9193 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9194 PyObject *resultobj = 0;
9195 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9196 PyObject *result = 0 ;
9197 void *argp1 = 0 ;
9198 int res1 = 0 ;
9199 PyObject *swig_obj[1] ;
9200
9201 if (!args) SWIG_fail;
9202 swig_obj[0] = args;
9203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9204 if (!SWIG_IsOK(res1)) {
9205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9206 }
9207 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9208 {
9209 PyThreadState* __tstate = wxPyBeginAllowThreads();
9210 result = (PyObject *)wxPoint2D_Get(arg1);
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 resultobj = result;
9215 return resultobj;
9216 fail:
9217 return NULL;
9218 }
9219
9220
9221 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222 PyObject *obj;
9223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9224 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9225 return SWIG_Py_Void();
9226 }
9227
9228 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9229 return SWIG_Python_InitShadowInstance(args);
9230 }
9231
9232 SWIGINTERN int DefaultPosition_set(PyObject *) {
9233 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9234 return 1;
9235 }
9236
9237
9238 SWIGINTERN PyObject *DefaultPosition_get(void) {
9239 PyObject *pyobj = 0;
9240
9241 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9242 return pyobj;
9243 }
9244
9245
9246 SWIGINTERN int DefaultSize_set(PyObject *) {
9247 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9248 return 1;
9249 }
9250
9251
9252 SWIGINTERN PyObject *DefaultSize_get(void) {
9253 PyObject *pyobj = 0;
9254
9255 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9256 return pyobj;
9257 }
9258
9259
9260 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj = 0;
9262 PyObject *arg1 = (PyObject *) 0 ;
9263 wxPyInputStream *result = 0 ;
9264 PyObject * obj0 = 0 ;
9265 char * kwnames[] = {
9266 (char *) "p", NULL
9267 };
9268
9269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9270 arg1 = obj0;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9285 PyObject *resultobj = 0;
9286 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 PyObject *swig_obj[1] ;
9290
9291 if (!args) SWIG_fail;
9292 swig_obj[0] = args;
9293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9294 if (!SWIG_IsOK(res1)) {
9295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9296 }
9297 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 delete arg1;
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 resultobj = SWIG_Py_Void();
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9313 PyObject *resultobj = 0;
9314 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 PyObject *swig_obj[1] ;
9318
9319 if (!args) SWIG_fail;
9320 swig_obj[0] = args;
9321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9322 if (!SWIG_IsOK(res1)) {
9323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9324 }
9325 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 (arg1)->close();
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 resultobj = SWIG_Py_Void();
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *resultobj = 0;
9341 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9342 void *argp1 = 0 ;
9343 int res1 = 0 ;
9344 PyObject *swig_obj[1] ;
9345
9346 if (!args) SWIG_fail;
9347 swig_obj[0] = args;
9348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9349 if (!SWIG_IsOK(res1)) {
9350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9351 }
9352 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 (arg1)->flush();
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 resultobj = SWIG_Py_Void();
9360 return resultobj;
9361 fail:
9362 return NULL;
9363 }
9364
9365
9366 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9367 PyObject *resultobj = 0;
9368 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9369 bool result;
9370 void *argp1 = 0 ;
9371 int res1 = 0 ;
9372 PyObject *swig_obj[1] ;
9373
9374 if (!args) SWIG_fail;
9375 swig_obj[0] = args;
9376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9377 if (!SWIG_IsOK(res1)) {
9378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9379 }
9380 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (bool)(arg1)->eof();
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9389 }
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj = 0;
9398 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9399 int arg2 = (int) -1 ;
9400 PyObject *result = 0 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 int val2 ;
9404 int ecode2 = 0 ;
9405 PyObject * obj0 = 0 ;
9406 PyObject * obj1 = 0 ;
9407 char * kwnames[] = {
9408 (char *) "self",(char *) "size", NULL
9409 };
9410
9411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9413 if (!SWIG_IsOK(res1)) {
9414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9415 }
9416 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9417 if (obj1) {
9418 ecode2 = SWIG_AsVal_int(obj1, &val2);
9419 if (!SWIG_IsOK(ecode2)) {
9420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9421 }
9422 arg2 = static_cast< int >(val2);
9423 }
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (PyObject *)(arg1)->read(arg2);
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 resultobj = result;
9431 return resultobj;
9432 fail:
9433 return NULL;
9434 }
9435
9436
9437 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9438 PyObject *resultobj = 0;
9439 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9440 int arg2 = (int) -1 ;
9441 PyObject *result = 0 ;
9442 void *argp1 = 0 ;
9443 int res1 = 0 ;
9444 int val2 ;
9445 int ecode2 = 0 ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 char * kwnames[] = {
9449 (char *) "self",(char *) "size", NULL
9450 };
9451
9452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9454 if (!SWIG_IsOK(res1)) {
9455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9456 }
9457 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9458 if (obj1) {
9459 ecode2 = SWIG_AsVal_int(obj1, &val2);
9460 if (!SWIG_IsOK(ecode2)) {
9461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9462 }
9463 arg2 = static_cast< int >(val2);
9464 }
9465 {
9466 PyThreadState* __tstate = wxPyBeginAllowThreads();
9467 result = (PyObject *)(arg1)->readline(arg2);
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 resultobj = result;
9472 return resultobj;
9473 fail:
9474 return NULL;
9475 }
9476
9477
9478 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9479 PyObject *resultobj = 0;
9480 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9481 int arg2 = (int) -1 ;
9482 PyObject *result = 0 ;
9483 void *argp1 = 0 ;
9484 int res1 = 0 ;
9485 int val2 ;
9486 int ecode2 = 0 ;
9487 PyObject * obj0 = 0 ;
9488 PyObject * obj1 = 0 ;
9489 char * kwnames[] = {
9490 (char *) "self",(char *) "sizehint", NULL
9491 };
9492
9493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9495 if (!SWIG_IsOK(res1)) {
9496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9497 }
9498 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9499 if (obj1) {
9500 ecode2 = SWIG_AsVal_int(obj1, &val2);
9501 if (!SWIG_IsOK(ecode2)) {
9502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9503 }
9504 arg2 = static_cast< int >(val2);
9505 }
9506 {
9507 PyThreadState* __tstate = wxPyBeginAllowThreads();
9508 result = (PyObject *)(arg1)->readlines(arg2);
9509 wxPyEndAllowThreads(__tstate);
9510 if (PyErr_Occurred()) SWIG_fail;
9511 }
9512 resultobj = result;
9513 return resultobj;
9514 fail:
9515 return NULL;
9516 }
9517
9518
9519 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9520 PyObject *resultobj = 0;
9521 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9522 int arg2 ;
9523 int arg3 = (int) 0 ;
9524 void *argp1 = 0 ;
9525 int res1 = 0 ;
9526 int val2 ;
9527 int ecode2 = 0 ;
9528 int val3 ;
9529 int ecode3 = 0 ;
9530 PyObject * obj0 = 0 ;
9531 PyObject * obj1 = 0 ;
9532 PyObject * obj2 = 0 ;
9533 char * kwnames[] = {
9534 (char *) "self",(char *) "offset",(char *) "whence", NULL
9535 };
9536
9537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9539 if (!SWIG_IsOK(res1)) {
9540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9541 }
9542 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9543 ecode2 = SWIG_AsVal_int(obj1, &val2);
9544 if (!SWIG_IsOK(ecode2)) {
9545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9546 }
9547 arg2 = static_cast< int >(val2);
9548 if (obj2) {
9549 ecode3 = SWIG_AsVal_int(obj2, &val3);
9550 if (!SWIG_IsOK(ecode3)) {
9551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9552 }
9553 arg3 = static_cast< int >(val3);
9554 }
9555 {
9556 PyThreadState* __tstate = wxPyBeginAllowThreads();
9557 (arg1)->seek(arg2,arg3);
9558 wxPyEndAllowThreads(__tstate);
9559 if (PyErr_Occurred()) SWIG_fail;
9560 }
9561 resultobj = SWIG_Py_Void();
9562 return resultobj;
9563 fail:
9564 return NULL;
9565 }
9566
9567
9568 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9569 PyObject *resultobj = 0;
9570 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9571 int result;
9572 void *argp1 = 0 ;
9573 int res1 = 0 ;
9574 PyObject *swig_obj[1] ;
9575
9576 if (!args) SWIG_fail;
9577 swig_obj[0] = args;
9578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9579 if (!SWIG_IsOK(res1)) {
9580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9581 }
9582 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 result = (int)(arg1)->tell();
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 resultobj = SWIG_From_int(static_cast< int >(result));
9590 return resultobj;
9591 fail:
9592 return NULL;
9593 }
9594
9595
9596 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9597 PyObject *resultobj = 0;
9598 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9599 char result;
9600 void *argp1 = 0 ;
9601 int res1 = 0 ;
9602 PyObject *swig_obj[1] ;
9603
9604 if (!args) SWIG_fail;
9605 swig_obj[0] = args;
9606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9607 if (!SWIG_IsOK(res1)) {
9608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9609 }
9610 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 result = (char)(arg1)->Peek();
9614 wxPyEndAllowThreads(__tstate);
9615 if (PyErr_Occurred()) SWIG_fail;
9616 }
9617 resultobj = SWIG_From_char(static_cast< char >(result));
9618 return resultobj;
9619 fail:
9620 return NULL;
9621 }
9622
9623
9624 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9625 PyObject *resultobj = 0;
9626 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9627 char result;
9628 void *argp1 = 0 ;
9629 int res1 = 0 ;
9630 PyObject *swig_obj[1] ;
9631
9632 if (!args) SWIG_fail;
9633 swig_obj[0] = args;
9634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9635 if (!SWIG_IsOK(res1)) {
9636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9637 }
9638 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9639 {
9640 PyThreadState* __tstate = wxPyBeginAllowThreads();
9641 result = (char)(arg1)->GetC();
9642 wxPyEndAllowThreads(__tstate);
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 resultobj = SWIG_From_char(static_cast< char >(result));
9646 return resultobj;
9647 fail:
9648 return NULL;
9649 }
9650
9651
9652 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9653 PyObject *resultobj = 0;
9654 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9655 size_t result;
9656 void *argp1 = 0 ;
9657 int res1 = 0 ;
9658 PyObject *swig_obj[1] ;
9659
9660 if (!args) SWIG_fail;
9661 swig_obj[0] = args;
9662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9663 if (!SWIG_IsOK(res1)) {
9664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9665 }
9666 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9667 {
9668 PyThreadState* __tstate = wxPyBeginAllowThreads();
9669 result = (size_t)(arg1)->LastRead();
9670 wxPyEndAllowThreads(__tstate);
9671 if (PyErr_Occurred()) SWIG_fail;
9672 }
9673 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9674 return resultobj;
9675 fail:
9676 return NULL;
9677 }
9678
9679
9680 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9681 PyObject *resultobj = 0;
9682 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9683 bool result;
9684 void *argp1 = 0 ;
9685 int res1 = 0 ;
9686 PyObject *swig_obj[1] ;
9687
9688 if (!args) SWIG_fail;
9689 swig_obj[0] = args;
9690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9691 if (!SWIG_IsOK(res1)) {
9692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9693 }
9694 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 result = (bool)(arg1)->CanRead();
9698 wxPyEndAllowThreads(__tstate);
9699 if (PyErr_Occurred()) SWIG_fail;
9700 }
9701 {
9702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9703 }
9704 return resultobj;
9705 fail:
9706 return NULL;
9707 }
9708
9709
9710 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9711 PyObject *resultobj = 0;
9712 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9713 bool result;
9714 void *argp1 = 0 ;
9715 int res1 = 0 ;
9716 PyObject *swig_obj[1] ;
9717
9718 if (!args) SWIG_fail;
9719 swig_obj[0] = args;
9720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9721 if (!SWIG_IsOK(res1)) {
9722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9723 }
9724 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9725 {
9726 PyThreadState* __tstate = wxPyBeginAllowThreads();
9727 result = (bool)(arg1)->Eof();
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 {
9732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9733 }
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj = 0;
9742 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9743 char arg2 ;
9744 bool result;
9745 void *argp1 = 0 ;
9746 int res1 = 0 ;
9747 char val2 ;
9748 int ecode2 = 0 ;
9749 PyObject * obj0 = 0 ;
9750 PyObject * obj1 = 0 ;
9751 char * kwnames[] = {
9752 (char *) "self",(char *) "c", NULL
9753 };
9754
9755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9757 if (!SWIG_IsOK(res1)) {
9758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9759 }
9760 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9761 ecode2 = SWIG_AsVal_char(obj1, &val2);
9762 if (!SWIG_IsOK(ecode2)) {
9763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9764 }
9765 arg2 = static_cast< char >(val2);
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 result = (bool)(arg1)->Ungetch(arg2);
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 {
9773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9774 }
9775 return resultobj;
9776 fail:
9777 return NULL;
9778 }
9779
9780
9781 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9782 PyObject *resultobj = 0;
9783 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9784 long arg2 ;
9785 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9786 long result;
9787 void *argp1 = 0 ;
9788 int res1 = 0 ;
9789 long val2 ;
9790 int ecode2 = 0 ;
9791 int val3 ;
9792 int ecode3 = 0 ;
9793 PyObject * obj0 = 0 ;
9794 PyObject * obj1 = 0 ;
9795 PyObject * obj2 = 0 ;
9796 char * kwnames[] = {
9797 (char *) "self",(char *) "pos",(char *) "mode", NULL
9798 };
9799
9800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9804 }
9805 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9806 ecode2 = SWIG_AsVal_long(obj1, &val2);
9807 if (!SWIG_IsOK(ecode2)) {
9808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9809 }
9810 arg2 = static_cast< long >(val2);
9811 if (obj2) {
9812 ecode3 = SWIG_AsVal_int(obj2, &val3);
9813 if (!SWIG_IsOK(ecode3)) {
9814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9815 }
9816 arg3 = static_cast< wxSeekMode >(val3);
9817 }
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 result = (long)(arg1)->SeekI(arg2,arg3);
9821 wxPyEndAllowThreads(__tstate);
9822 if (PyErr_Occurred()) SWIG_fail;
9823 }
9824 resultobj = SWIG_From_long(static_cast< long >(result));
9825 return resultobj;
9826 fail:
9827 return NULL;
9828 }
9829
9830
9831 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *resultobj = 0;
9833 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9834 long result;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 PyObject *swig_obj[1] ;
9838
9839 if (!args) SWIG_fail;
9840 swig_obj[0] = args;
9841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9842 if (!SWIG_IsOK(res1)) {
9843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9844 }
9845 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 result = (long)(arg1)->TellI();
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 resultobj = SWIG_From_long(static_cast< long >(result));
9853 return resultobj;
9854 fail:
9855 return NULL;
9856 }
9857
9858
9859 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9860 PyObject *obj;
9861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9862 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9863 return SWIG_Py_Void();
9864 }
9865
9866 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9867 return SWIG_Python_InitShadowInstance(args);
9868 }
9869
9870 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9871 PyObject *resultobj = 0;
9872 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9873 PyObject *arg2 = (PyObject *) 0 ;
9874 void *argp1 = 0 ;
9875 int res1 = 0 ;
9876 PyObject * obj0 = 0 ;
9877 PyObject * obj1 = 0 ;
9878 char * kwnames[] = {
9879 (char *) "self",(char *) "obj", NULL
9880 };
9881
9882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9884 if (!SWIG_IsOK(res1)) {
9885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9886 }
9887 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9888 arg2 = obj1;
9889 {
9890 PyThreadState* __tstate = wxPyBeginAllowThreads();
9891 wxOutputStream_write(arg1,arg2);
9892 wxPyEndAllowThreads(__tstate);
9893 if (PyErr_Occurred()) SWIG_fail;
9894 }
9895 resultobj = SWIG_Py_Void();
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *resultobj = 0;
9904 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9905 size_t result;
9906 void *argp1 = 0 ;
9907 int res1 = 0 ;
9908 PyObject *swig_obj[1] ;
9909
9910 if (!args) SWIG_fail;
9911 swig_obj[0] = args;
9912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9913 if (!SWIG_IsOK(res1)) {
9914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9915 }
9916 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9920 wxPyEndAllowThreads(__tstate);
9921 if (PyErr_Occurred()) SWIG_fail;
9922 }
9923 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 PyObject *obj;
9932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9933 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9934 return SWIG_Py_Void();
9935 }
9936
9937 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj = 0;
9939 wxInputStream *arg1 = (wxInputStream *) 0 ;
9940 wxString *arg2 = 0 ;
9941 wxString *arg3 = 0 ;
9942 wxString *arg4 = 0 ;
9943 wxDateTime arg5 ;
9944 wxFSFile *result = 0 ;
9945 wxPyInputStream *temp1 ;
9946 bool temp2 = false ;
9947 bool temp3 = false ;
9948 bool temp4 = false ;
9949 void *argp5 ;
9950 int res5 = 0 ;
9951 PyObject * obj0 = 0 ;
9952 PyObject * obj1 = 0 ;
9953 PyObject * obj2 = 0 ;
9954 PyObject * obj3 = 0 ;
9955 PyObject * obj4 = 0 ;
9956 char * kwnames[] = {
9957 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9958 };
9959
9960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9961 {
9962 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9963 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9964 } else {
9965 PyErr_Clear(); // clear the failure of the wxPyConvert above
9966 arg1 = wxPyCBInputStream_create(obj0, true);
9967 if (arg1 == NULL) {
9968 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9969 SWIG_fail;
9970 }
9971 }
9972 }
9973 {
9974 arg2 = wxString_in_helper(obj1);
9975 if (arg2 == NULL) SWIG_fail;
9976 temp2 = true;
9977 }
9978 {
9979 arg3 = wxString_in_helper(obj2);
9980 if (arg3 == NULL) SWIG_fail;
9981 temp3 = true;
9982 }
9983 {
9984 arg4 = wxString_in_helper(obj3);
9985 if (arg4 == NULL) SWIG_fail;
9986 temp4 = true;
9987 }
9988 {
9989 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9990 if (!SWIG_IsOK(res5)) {
9991 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9992 }
9993 if (!argp5) {
9994 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9995 } else {
9996 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9997 arg5 = *temp;
9998 if (SWIG_IsNewObj(res5)) delete temp;
9999 }
10000 }
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
10004 wxPyEndAllowThreads(__tstate);
10005 if (PyErr_Occurred()) SWIG_fail;
10006 }
10007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
10008 {
10009 if (temp2)
10010 delete arg2;
10011 }
10012 {
10013 if (temp3)
10014 delete arg3;
10015 }
10016 {
10017 if (temp4)
10018 delete arg4;
10019 }
10020 return resultobj;
10021 fail:
10022 {
10023 if (temp2)
10024 delete arg2;
10025 }
10026 {
10027 if (temp3)
10028 delete arg3;
10029 }
10030 {
10031 if (temp4)
10032 delete arg4;
10033 }
10034 return NULL;
10035 }
10036
10037
10038 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10039 PyObject *resultobj = 0;
10040 wxFSFile *arg1 = (wxFSFile *) 0 ;
10041 void *argp1 = 0 ;
10042 int res1 = 0 ;
10043 PyObject *swig_obj[1] ;
10044
10045 if (!args) SWIG_fail;
10046 swig_obj[0] = args;
10047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10048 if (!SWIG_IsOK(res1)) {
10049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10050 }
10051 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10052 {
10053 PyThreadState* __tstate = wxPyBeginAllowThreads();
10054 delete arg1;
10055
10056 wxPyEndAllowThreads(__tstate);
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 resultobj = SWIG_Py_Void();
10060 return resultobj;
10061 fail:
10062 return NULL;
10063 }
10064
10065
10066 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10067 PyObject *resultobj = 0;
10068 wxFSFile *arg1 = (wxFSFile *) 0 ;
10069 wxInputStream *result = 0 ;
10070 void *argp1 = 0 ;
10071 int res1 = 0 ;
10072 PyObject *swig_obj[1] ;
10073
10074 if (!args) SWIG_fail;
10075 swig_obj[0] = args;
10076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10077 if (!SWIG_IsOK(res1)) {
10078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10079 }
10080 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 result = (wxInputStream *)(arg1)->GetStream();
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 {
10088 wxPyInputStream * _ptr = NULL;
10089
10090 if (result) {
10091 _ptr = new wxPyInputStream(result);
10092 }
10093 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10094 }
10095 return resultobj;
10096 fail:
10097 return NULL;
10098 }
10099
10100
10101 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10102 PyObject *resultobj = 0;
10103 wxFSFile *arg1 = (wxFSFile *) 0 ;
10104 void *argp1 = 0 ;
10105 int res1 = 0 ;
10106 PyObject *swig_obj[1] ;
10107
10108 if (!args) SWIG_fail;
10109 swig_obj[0] = args;
10110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10111 if (!SWIG_IsOK(res1)) {
10112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10113 }
10114 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 (arg1)->DetachStream();
10118 wxPyEndAllowThreads(__tstate);
10119 if (PyErr_Occurred()) SWIG_fail;
10120 }
10121 resultobj = SWIG_Py_Void();
10122 return resultobj;
10123 fail:
10124 return NULL;
10125 }
10126
10127
10128 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10129 PyObject *resultobj = 0;
10130 wxFSFile *arg1 = (wxFSFile *) 0 ;
10131 wxString *result = 0 ;
10132 void *argp1 = 0 ;
10133 int res1 = 0 ;
10134 PyObject *swig_obj[1] ;
10135
10136 if (!args) SWIG_fail;
10137 swig_obj[0] = args;
10138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10139 if (!SWIG_IsOK(res1)) {
10140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10141 }
10142 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 {
10146 wxString const &_result_ref = (arg1)->GetMimeType();
10147 result = (wxString *) &_result_ref;
10148 }
10149 wxPyEndAllowThreads(__tstate);
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 {
10153 #if wxUSE_UNICODE
10154 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10155 #else
10156 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10157 #endif
10158 }
10159 return resultobj;
10160 fail:
10161 return NULL;
10162 }
10163
10164
10165 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10166 PyObject *resultobj = 0;
10167 wxFSFile *arg1 = (wxFSFile *) 0 ;
10168 wxString *result = 0 ;
10169 void *argp1 = 0 ;
10170 int res1 = 0 ;
10171 PyObject *swig_obj[1] ;
10172
10173 if (!args) SWIG_fail;
10174 swig_obj[0] = args;
10175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10176 if (!SWIG_IsOK(res1)) {
10177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10178 }
10179 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 {
10183 wxString const &_result_ref = (arg1)->GetLocation();
10184 result = (wxString *) &_result_ref;
10185 }
10186 wxPyEndAllowThreads(__tstate);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 {
10190 #if wxUSE_UNICODE
10191 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10192 #else
10193 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10194 #endif
10195 }
10196 return resultobj;
10197 fail:
10198 return NULL;
10199 }
10200
10201
10202 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10203 PyObject *resultobj = 0;
10204 wxFSFile *arg1 = (wxFSFile *) 0 ;
10205 wxString *result = 0 ;
10206 void *argp1 = 0 ;
10207 int res1 = 0 ;
10208 PyObject *swig_obj[1] ;
10209
10210 if (!args) SWIG_fail;
10211 swig_obj[0] = args;
10212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10213 if (!SWIG_IsOK(res1)) {
10214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10215 }
10216 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 {
10220 wxString const &_result_ref = (arg1)->GetAnchor();
10221 result = (wxString *) &_result_ref;
10222 }
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 {
10227 #if wxUSE_UNICODE
10228 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10229 #else
10230 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10231 #endif
10232 }
10233 return resultobj;
10234 fail:
10235 return NULL;
10236 }
10237
10238
10239 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10240 PyObject *resultobj = 0;
10241 wxFSFile *arg1 = (wxFSFile *) 0 ;
10242 wxDateTime result;
10243 void *argp1 = 0 ;
10244 int res1 = 0 ;
10245 PyObject *swig_obj[1] ;
10246
10247 if (!args) SWIG_fail;
10248 swig_obj[0] = args;
10249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10250 if (!SWIG_IsOK(res1)) {
10251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10252 }
10253 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 result = (arg1)->GetModificationTime();
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10261 return resultobj;
10262 fail:
10263 return NULL;
10264 }
10265
10266
10267 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10268 PyObject *obj;
10269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10270 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10271 return SWIG_Py_Void();
10272 }
10273
10274 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10275 return SWIG_Python_InitShadowInstance(args);
10276 }
10277
10278 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10279 PyObject *resultobj = 0;
10280 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10281 void *argp1 = 0 ;
10282 int res1 = 0 ;
10283 PyObject *swig_obj[1] ;
10284
10285 if (!args) SWIG_fail;
10286 swig_obj[0] = args;
10287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10288 if (!SWIG_IsOK(res1)) {
10289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10290 }
10291 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10292 {
10293 PyThreadState* __tstate = wxPyBeginAllowThreads();
10294 delete arg1;
10295
10296 wxPyEndAllowThreads(__tstate);
10297 if (PyErr_Occurred()) SWIG_fail;
10298 }
10299 resultobj = SWIG_Py_Void();
10300 return resultobj;
10301 fail:
10302 return NULL;
10303 }
10304
10305
10306 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10307 PyObject *obj;
10308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10309 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10310 return SWIG_Py_Void();
10311 }
10312
10313 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10314 PyObject *resultobj = 0;
10315 wxPyFileSystemHandler *result = 0 ;
10316
10317 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10318 {
10319 PyThreadState* __tstate = wxPyBeginAllowThreads();
10320 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10321 wxPyEndAllowThreads(__tstate);
10322 if (PyErr_Occurred()) SWIG_fail;
10323 }
10324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10325 return resultobj;
10326 fail:
10327 return NULL;
10328 }
10329
10330
10331 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10332 PyObject *resultobj = 0;
10333 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10334 PyObject *arg2 = (PyObject *) 0 ;
10335 PyObject *arg3 = (PyObject *) 0 ;
10336 void *argp1 = 0 ;
10337 int res1 = 0 ;
10338 PyObject * obj0 = 0 ;
10339 PyObject * obj1 = 0 ;
10340 PyObject * obj2 = 0 ;
10341 char * kwnames[] = {
10342 (char *) "self",(char *) "self",(char *) "_class", NULL
10343 };
10344
10345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10347 if (!SWIG_IsOK(res1)) {
10348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10349 }
10350 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10351 arg2 = obj1;
10352 arg3 = obj2;
10353 {
10354 PyThreadState* __tstate = wxPyBeginAllowThreads();
10355 (arg1)->_setCallbackInfo(arg2,arg3);
10356 wxPyEndAllowThreads(__tstate);
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 resultobj = SWIG_Py_Void();
10360 return resultobj;
10361 fail:
10362 return NULL;
10363 }
10364
10365
10366 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10367 PyObject *resultobj = 0;
10368 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10369 wxString *arg2 = 0 ;
10370 bool result;
10371 void *argp1 = 0 ;
10372 int res1 = 0 ;
10373 bool temp2 = false ;
10374 PyObject * obj0 = 0 ;
10375 PyObject * obj1 = 0 ;
10376 char * kwnames[] = {
10377 (char *) "self",(char *) "location", NULL
10378 };
10379
10380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10384 }
10385 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10386 {
10387 arg2 = wxString_in_helper(obj1);
10388 if (arg2 == NULL) SWIG_fail;
10389 temp2 = true;
10390 }
10391 {
10392 PyThreadState* __tstate = wxPyBeginAllowThreads();
10393 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10394 wxPyEndAllowThreads(__tstate);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 {
10398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10399 }
10400 {
10401 if (temp2)
10402 delete arg2;
10403 }
10404 return resultobj;
10405 fail:
10406 {
10407 if (temp2)
10408 delete arg2;
10409 }
10410 return NULL;
10411 }
10412
10413
10414 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10415 PyObject *resultobj = 0;
10416 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10417 wxFileSystem *arg2 = 0 ;
10418 wxString *arg3 = 0 ;
10419 wxFSFile *result = 0 ;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 void *argp2 = 0 ;
10423 int res2 = 0 ;
10424 bool temp3 = false ;
10425 PyObject * obj0 = 0 ;
10426 PyObject * obj1 = 0 ;
10427 PyObject * obj2 = 0 ;
10428 char * kwnames[] = {
10429 (char *) "self",(char *) "fs",(char *) "location", NULL
10430 };
10431
10432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10434 if (!SWIG_IsOK(res1)) {
10435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10436 }
10437 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10438 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10439 if (!SWIG_IsOK(res2)) {
10440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10441 }
10442 if (!argp2) {
10443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10444 }
10445 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10446 {
10447 arg3 = wxString_in_helper(obj2);
10448 if (arg3 == NULL) SWIG_fail;
10449 temp3 = true;
10450 }
10451 {
10452 PyThreadState* __tstate = wxPyBeginAllowThreads();
10453 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 {
10458 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10459 }
10460 {
10461 if (temp3)
10462 delete arg3;
10463 }
10464 return resultobj;
10465 fail:
10466 {
10467 if (temp3)
10468 delete arg3;
10469 }
10470 return NULL;
10471 }
10472
10473
10474 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10475 PyObject *resultobj = 0;
10476 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10477 wxString *arg2 = 0 ;
10478 int arg3 = (int) 0 ;
10479 wxString result;
10480 void *argp1 = 0 ;
10481 int res1 = 0 ;
10482 bool temp2 = false ;
10483 int val3 ;
10484 int ecode3 = 0 ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487 PyObject * obj2 = 0 ;
10488 char * kwnames[] = {
10489 (char *) "self",(char *) "spec",(char *) "flags", NULL
10490 };
10491
10492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10494 if (!SWIG_IsOK(res1)) {
10495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10496 }
10497 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10498 {
10499 arg2 = wxString_in_helper(obj1);
10500 if (arg2 == NULL) SWIG_fail;
10501 temp2 = true;
10502 }
10503 if (obj2) {
10504 ecode3 = SWIG_AsVal_int(obj2, &val3);
10505 if (!SWIG_IsOK(ecode3)) {
10506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10507 }
10508 arg3 = static_cast< int >(val3);
10509 }
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 {
10517 #if wxUSE_UNICODE
10518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10519 #else
10520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10521 #endif
10522 }
10523 {
10524 if (temp2)
10525 delete arg2;
10526 }
10527 return resultobj;
10528 fail:
10529 {
10530 if (temp2)
10531 delete arg2;
10532 }
10533 return NULL;
10534 }
10535
10536
10537 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10538 PyObject *resultobj = 0;
10539 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10540 wxString result;
10541 void *argp1 = 0 ;
10542 int res1 = 0 ;
10543 PyObject *swig_obj[1] ;
10544
10545 if (!args) SWIG_fail;
10546 swig_obj[0] = args;
10547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10548 if (!SWIG_IsOK(res1)) {
10549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10550 }
10551 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 result = (arg1)->FindNext();
10555 wxPyEndAllowThreads(__tstate);
10556 if (PyErr_Occurred()) SWIG_fail;
10557 }
10558 {
10559 #if wxUSE_UNICODE
10560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10561 #else
10562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10563 #endif
10564 }
10565 return resultobj;
10566 fail:
10567 return NULL;
10568 }
10569
10570
10571 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10572 PyObject *resultobj = 0;
10573 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10574 wxString *arg2 = 0 ;
10575 wxString result;
10576 void *argp1 = 0 ;
10577 int res1 = 0 ;
10578 bool temp2 = false ;
10579 PyObject * obj0 = 0 ;
10580 PyObject * obj1 = 0 ;
10581 char * kwnames[] = {
10582 (char *) "self",(char *) "location", NULL
10583 };
10584
10585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10589 }
10590 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10591 {
10592 arg2 = wxString_in_helper(obj1);
10593 if (arg2 == NULL) SWIG_fail;
10594 temp2 = true;
10595 }
10596 {
10597 PyThreadState* __tstate = wxPyBeginAllowThreads();
10598 result = (arg1)->GetProtocol((wxString const &)*arg2);
10599 wxPyEndAllowThreads(__tstate);
10600 if (PyErr_Occurred()) SWIG_fail;
10601 }
10602 {
10603 #if wxUSE_UNICODE
10604 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10605 #else
10606 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10607 #endif
10608 }
10609 {
10610 if (temp2)
10611 delete arg2;
10612 }
10613 return resultobj;
10614 fail:
10615 {
10616 if (temp2)
10617 delete arg2;
10618 }
10619 return NULL;
10620 }
10621
10622
10623 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10624 PyObject *resultobj = 0;
10625 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10626 wxString *arg2 = 0 ;
10627 wxString result;
10628 void *argp1 = 0 ;
10629 int res1 = 0 ;
10630 bool temp2 = false ;
10631 PyObject * obj0 = 0 ;
10632 PyObject * obj1 = 0 ;
10633 char * kwnames[] = {
10634 (char *) "self",(char *) "location", NULL
10635 };
10636
10637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10639 if (!SWIG_IsOK(res1)) {
10640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10641 }
10642 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10643 {
10644 arg2 = wxString_in_helper(obj1);
10645 if (arg2 == NULL) SWIG_fail;
10646 temp2 = true;
10647 }
10648 {
10649 PyThreadState* __tstate = wxPyBeginAllowThreads();
10650 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10651 wxPyEndAllowThreads(__tstate);
10652 if (PyErr_Occurred()) SWIG_fail;
10653 }
10654 {
10655 #if wxUSE_UNICODE
10656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10657 #else
10658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10659 #endif
10660 }
10661 {
10662 if (temp2)
10663 delete arg2;
10664 }
10665 return resultobj;
10666 fail:
10667 {
10668 if (temp2)
10669 delete arg2;
10670 }
10671 return NULL;
10672 }
10673
10674
10675 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj = 0;
10677 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10678 wxString *arg2 = 0 ;
10679 wxString result;
10680 void *argp1 = 0 ;
10681 int res1 = 0 ;
10682 bool temp2 = false ;
10683 PyObject * obj0 = 0 ;
10684 PyObject * obj1 = 0 ;
10685 char * kwnames[] = {
10686 (char *) "self",(char *) "location", NULL
10687 };
10688
10689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10691 if (!SWIG_IsOK(res1)) {
10692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10693 }
10694 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10695 {
10696 arg2 = wxString_in_helper(obj1);
10697 if (arg2 == NULL) SWIG_fail;
10698 temp2 = true;
10699 }
10700 {
10701 PyThreadState* __tstate = wxPyBeginAllowThreads();
10702 result = (arg1)->GetAnchor((wxString const &)*arg2);
10703 wxPyEndAllowThreads(__tstate);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 {
10707 #if wxUSE_UNICODE
10708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10709 #else
10710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10711 #endif
10712 }
10713 {
10714 if (temp2)
10715 delete arg2;
10716 }
10717 return resultobj;
10718 fail:
10719 {
10720 if (temp2)
10721 delete arg2;
10722 }
10723 return NULL;
10724 }
10725
10726
10727 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10728 PyObject *resultobj = 0;
10729 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10730 wxString *arg2 = 0 ;
10731 wxString result;
10732 void *argp1 = 0 ;
10733 int res1 = 0 ;
10734 bool temp2 = false ;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 char * kwnames[] = {
10738 (char *) "self",(char *) "location", NULL
10739 };
10740
10741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10743 if (!SWIG_IsOK(res1)) {
10744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10745 }
10746 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10747 {
10748 arg2 = wxString_in_helper(obj1);
10749 if (arg2 == NULL) SWIG_fail;
10750 temp2 = true;
10751 }
10752 {
10753 PyThreadState* __tstate = wxPyBeginAllowThreads();
10754 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 {
10759 #if wxUSE_UNICODE
10760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10761 #else
10762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10763 #endif
10764 }
10765 {
10766 if (temp2)
10767 delete arg2;
10768 }
10769 return resultobj;
10770 fail:
10771 {
10772 if (temp2)
10773 delete arg2;
10774 }
10775 return NULL;
10776 }
10777
10778
10779 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10780 PyObject *resultobj = 0;
10781 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10782 wxString *arg2 = 0 ;
10783 wxString result;
10784 void *argp1 = 0 ;
10785 int res1 = 0 ;
10786 bool temp2 = false ;
10787 PyObject * obj0 = 0 ;
10788 PyObject * obj1 = 0 ;
10789 char * kwnames[] = {
10790 (char *) "self",(char *) "location", NULL
10791 };
10792
10793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10795 if (!SWIG_IsOK(res1)) {
10796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10797 }
10798 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10799 {
10800 arg2 = wxString_in_helper(obj1);
10801 if (arg2 == NULL) SWIG_fail;
10802 temp2 = true;
10803 }
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 {
10811 #if wxUSE_UNICODE
10812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10813 #else
10814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10815 #endif
10816 }
10817 {
10818 if (temp2)
10819 delete arg2;
10820 }
10821 return resultobj;
10822 fail:
10823 {
10824 if (temp2)
10825 delete arg2;
10826 }
10827 return NULL;
10828 }
10829
10830
10831 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10832 PyObject *obj;
10833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10834 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10835 return SWIG_Py_Void();
10836 }
10837
10838 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10839 return SWIG_Python_InitShadowInstance(args);
10840 }
10841
10842 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10843 PyObject *resultobj = 0;
10844 wxFileSystem *result = 0 ;
10845
10846 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10847 {
10848 PyThreadState* __tstate = wxPyBeginAllowThreads();
10849 result = (wxFileSystem *)new wxFileSystem();
10850 wxPyEndAllowThreads(__tstate);
10851 if (PyErr_Occurred()) SWIG_fail;
10852 }
10853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
10854 return resultobj;
10855 fail:
10856 return NULL;
10857 }
10858
10859
10860 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10861 PyObject *resultobj = 0;
10862 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10863 void *argp1 = 0 ;
10864 int res1 = 0 ;
10865 PyObject *swig_obj[1] ;
10866
10867 if (!args) SWIG_fail;
10868 swig_obj[0] = args;
10869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10870 if (!SWIG_IsOK(res1)) {
10871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10872 }
10873 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10874 {
10875 PyThreadState* __tstate = wxPyBeginAllowThreads();
10876 delete arg1;
10877
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 resultobj = SWIG_Py_Void();
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj = 0;
10890 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10891 wxString *arg2 = 0 ;
10892 bool arg3 = (bool) false ;
10893 void *argp1 = 0 ;
10894 int res1 = 0 ;
10895 bool temp2 = false ;
10896 bool val3 ;
10897 int ecode3 = 0 ;
10898 PyObject * obj0 = 0 ;
10899 PyObject * obj1 = 0 ;
10900 PyObject * obj2 = 0 ;
10901 char * kwnames[] = {
10902 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10903 };
10904
10905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10909 }
10910 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10911 {
10912 arg2 = wxString_in_helper(obj1);
10913 if (arg2 == NULL) SWIG_fail;
10914 temp2 = true;
10915 }
10916 if (obj2) {
10917 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10918 if (!SWIG_IsOK(ecode3)) {
10919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10920 }
10921 arg3 = static_cast< bool >(val3);
10922 }
10923 {
10924 PyThreadState* __tstate = wxPyBeginAllowThreads();
10925 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10926 wxPyEndAllowThreads(__tstate);
10927 if (PyErr_Occurred()) SWIG_fail;
10928 }
10929 resultobj = SWIG_Py_Void();
10930 {
10931 if (temp2)
10932 delete arg2;
10933 }
10934 return resultobj;
10935 fail:
10936 {
10937 if (temp2)
10938 delete arg2;
10939 }
10940 return NULL;
10941 }
10942
10943
10944 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10945 PyObject *resultobj = 0;
10946 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10947 wxString result;
10948 void *argp1 = 0 ;
10949 int res1 = 0 ;
10950 PyObject *swig_obj[1] ;
10951
10952 if (!args) SWIG_fail;
10953 swig_obj[0] = args;
10954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10955 if (!SWIG_IsOK(res1)) {
10956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10957 }
10958 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10959 {
10960 PyThreadState* __tstate = wxPyBeginAllowThreads();
10961 result = (arg1)->GetPath();
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 {
10966 #if wxUSE_UNICODE
10967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10968 #else
10969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10970 #endif
10971 }
10972 return resultobj;
10973 fail:
10974 return NULL;
10975 }
10976
10977
10978 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10979 PyObject *resultobj = 0;
10980 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10981 wxString *arg2 = 0 ;
10982 wxFSFile *result = 0 ;
10983 void *argp1 = 0 ;
10984 int res1 = 0 ;
10985 bool temp2 = false ;
10986 PyObject * obj0 = 0 ;
10987 PyObject * obj1 = 0 ;
10988 char * kwnames[] = {
10989 (char *) "self",(char *) "location", NULL
10990 };
10991
10992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10994 if (!SWIG_IsOK(res1)) {
10995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10996 }
10997 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10998 {
10999 arg2 = wxString_in_helper(obj1);
11000 if (arg2 == NULL) SWIG_fail;
11001 temp2 = true;
11002 }
11003 {
11004 PyThreadState* __tstate = wxPyBeginAllowThreads();
11005 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11011 }
11012 {
11013 if (temp2)
11014 delete arg2;
11015 }
11016 return resultobj;
11017 fail:
11018 {
11019 if (temp2)
11020 delete arg2;
11021 }
11022 return NULL;
11023 }
11024
11025
11026 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11027 PyObject *resultobj = 0;
11028 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11029 wxString *arg2 = 0 ;
11030 int arg3 = (int) 0 ;
11031 wxString result;
11032 void *argp1 = 0 ;
11033 int res1 = 0 ;
11034 bool temp2 = false ;
11035 int val3 ;
11036 int ecode3 = 0 ;
11037 PyObject * obj0 = 0 ;
11038 PyObject * obj1 = 0 ;
11039 PyObject * obj2 = 0 ;
11040 char * kwnames[] = {
11041 (char *) "self",(char *) "spec",(char *) "flags", NULL
11042 };
11043
11044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11046 if (!SWIG_IsOK(res1)) {
11047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11048 }
11049 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11050 {
11051 arg2 = wxString_in_helper(obj1);
11052 if (arg2 == NULL) SWIG_fail;
11053 temp2 = true;
11054 }
11055 if (obj2) {
11056 ecode3 = SWIG_AsVal_int(obj2, &val3);
11057 if (!SWIG_IsOK(ecode3)) {
11058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11059 }
11060 arg3 = static_cast< int >(val3);
11061 }
11062 {
11063 PyThreadState* __tstate = wxPyBeginAllowThreads();
11064 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11065 wxPyEndAllowThreads(__tstate);
11066 if (PyErr_Occurred()) SWIG_fail;
11067 }
11068 {
11069 #if wxUSE_UNICODE
11070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11071 #else
11072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11073 #endif
11074 }
11075 {
11076 if (temp2)
11077 delete arg2;
11078 }
11079 return resultobj;
11080 fail:
11081 {
11082 if (temp2)
11083 delete arg2;
11084 }
11085 return NULL;
11086 }
11087
11088
11089 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11090 PyObject *resultobj = 0;
11091 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11092 wxString result;
11093 void *argp1 = 0 ;
11094 int res1 = 0 ;
11095 PyObject *swig_obj[1] ;
11096
11097 if (!args) SWIG_fail;
11098 swig_obj[0] = args;
11099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11100 if (!SWIG_IsOK(res1)) {
11101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11102 }
11103 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11104 {
11105 PyThreadState* __tstate = wxPyBeginAllowThreads();
11106 result = (arg1)->FindNext();
11107 wxPyEndAllowThreads(__tstate);
11108 if (PyErr_Occurred()) SWIG_fail;
11109 }
11110 {
11111 #if wxUSE_UNICODE
11112 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11113 #else
11114 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11115 #endif
11116 }
11117 return resultobj;
11118 fail:
11119 return NULL;
11120 }
11121
11122
11123 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11124 PyObject *resultobj = 0;
11125 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11126 int res1 = 0 ;
11127 PyObject * obj0 = 0 ;
11128 char * kwnames[] = {
11129 (char *) "handler", NULL
11130 };
11131
11132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11133 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11134 if (!SWIG_IsOK(res1)) {
11135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11136 }
11137 {
11138 PyThreadState* __tstate = wxPyBeginAllowThreads();
11139 wxFileSystem::AddHandler(arg1);
11140 wxPyEndAllowThreads(__tstate);
11141 if (PyErr_Occurred()) SWIG_fail;
11142 }
11143 resultobj = SWIG_Py_Void();
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11151 PyObject *resultobj = 0;
11152 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11153 wxFileSystemHandler *result = 0 ;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 PyObject * obj0 = 0 ;
11157 char * kwnames[] = {
11158 (char *) "handler", NULL
11159 };
11160
11161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11163 if (!SWIG_IsOK(res1)) {
11164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11165 }
11166 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11170 wxPyEndAllowThreads(__tstate);
11171 if (PyErr_Occurred()) SWIG_fail;
11172 }
11173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11174 return resultobj;
11175 fail:
11176 return NULL;
11177 }
11178
11179
11180 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11181 PyObject *resultobj = 0;
11182
11183 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 wxFileSystem::CleanUpHandlers();
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 resultobj = SWIG_Py_Void();
11191 return resultobj;
11192 fail:
11193 return NULL;
11194 }
11195
11196
11197 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11198 PyObject *resultobj = 0;
11199 wxString *arg1 = 0 ;
11200 wxString result;
11201 bool temp1 = false ;
11202 PyObject * obj0 = 0 ;
11203 char * kwnames[] = {
11204 (char *) "filename", NULL
11205 };
11206
11207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11208 {
11209 arg1 = wxString_in_helper(obj0);
11210 if (arg1 == NULL) SWIG_fail;
11211 temp1 = true;
11212 }
11213 {
11214 PyThreadState* __tstate = wxPyBeginAllowThreads();
11215 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11216 wxPyEndAllowThreads(__tstate);
11217 if (PyErr_Occurred()) SWIG_fail;
11218 }
11219 {
11220 #if wxUSE_UNICODE
11221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11222 #else
11223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11224 #endif
11225 }
11226 {
11227 if (temp1)
11228 delete arg1;
11229 }
11230 return resultobj;
11231 fail:
11232 {
11233 if (temp1)
11234 delete arg1;
11235 }
11236 return NULL;
11237 }
11238
11239
11240 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11241 PyObject *resultobj = 0;
11242 wxString *arg1 = 0 ;
11243 wxString result;
11244 bool temp1 = false ;
11245 PyObject * obj0 = 0 ;
11246 char * kwnames[] = {
11247 (char *) "url", NULL
11248 };
11249
11250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11251 {
11252 arg1 = wxString_in_helper(obj0);
11253 if (arg1 == NULL) SWIG_fail;
11254 temp1 = true;
11255 }
11256 {
11257 PyThreadState* __tstate = wxPyBeginAllowThreads();
11258 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 {
11263 #if wxUSE_UNICODE
11264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11265 #else
11266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11267 #endif
11268 }
11269 {
11270 if (temp1)
11271 delete arg1;
11272 }
11273 return resultobj;
11274 fail:
11275 {
11276 if (temp1)
11277 delete arg1;
11278 }
11279 return NULL;
11280 }
11281
11282
11283 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11284 PyObject *obj;
11285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11286 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11287 return SWIG_Py_Void();
11288 }
11289
11290 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11291 return SWIG_Python_InitShadowInstance(args);
11292 }
11293
11294 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11295 PyObject *resultobj = 0;
11296 wxInternetFSHandler *result = 0 ;
11297
11298 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11306 return resultobj;
11307 fail:
11308 return NULL;
11309 }
11310
11311
11312 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11313 PyObject *resultobj = 0;
11314 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11315 wxString *arg2 = 0 ;
11316 bool result;
11317 void *argp1 = 0 ;
11318 int res1 = 0 ;
11319 bool temp2 = false ;
11320 PyObject * obj0 = 0 ;
11321 PyObject * obj1 = 0 ;
11322 char * kwnames[] = {
11323 (char *) "self",(char *) "location", NULL
11324 };
11325
11326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11328 if (!SWIG_IsOK(res1)) {
11329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11330 }
11331 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11332 {
11333 arg2 = wxString_in_helper(obj1);
11334 if (arg2 == NULL) SWIG_fail;
11335 temp2 = true;
11336 }
11337 {
11338 PyThreadState* __tstate = wxPyBeginAllowThreads();
11339 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11340 wxPyEndAllowThreads(__tstate);
11341 if (PyErr_Occurred()) SWIG_fail;
11342 }
11343 {
11344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11345 }
11346 {
11347 if (temp2)
11348 delete arg2;
11349 }
11350 return resultobj;
11351 fail:
11352 {
11353 if (temp2)
11354 delete arg2;
11355 }
11356 return NULL;
11357 }
11358
11359
11360 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11361 PyObject *resultobj = 0;
11362 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11363 wxFileSystem *arg2 = 0 ;
11364 wxString *arg3 = 0 ;
11365 wxFSFile *result = 0 ;
11366 void *argp1 = 0 ;
11367 int res1 = 0 ;
11368 void *argp2 = 0 ;
11369 int res2 = 0 ;
11370 bool temp3 = false ;
11371 PyObject * obj0 = 0 ;
11372 PyObject * obj1 = 0 ;
11373 PyObject * obj2 = 0 ;
11374 char * kwnames[] = {
11375 (char *) "self",(char *) "fs",(char *) "location", NULL
11376 };
11377
11378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11380 if (!SWIG_IsOK(res1)) {
11381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11382 }
11383 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11384 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11385 if (!SWIG_IsOK(res2)) {
11386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11387 }
11388 if (!argp2) {
11389 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11390 }
11391 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11392 {
11393 arg3 = wxString_in_helper(obj2);
11394 if (arg3 == NULL) SWIG_fail;
11395 temp3 = true;
11396 }
11397 {
11398 PyThreadState* __tstate = wxPyBeginAllowThreads();
11399 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11400 wxPyEndAllowThreads(__tstate);
11401 if (PyErr_Occurred()) SWIG_fail;
11402 }
11403 {
11404 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11405 }
11406 {
11407 if (temp3)
11408 delete arg3;
11409 }
11410 return resultobj;
11411 fail:
11412 {
11413 if (temp3)
11414 delete arg3;
11415 }
11416 return NULL;
11417 }
11418
11419
11420 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11421 PyObject *obj;
11422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11423 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11424 return SWIG_Py_Void();
11425 }
11426
11427 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11428 return SWIG_Python_InitShadowInstance(args);
11429 }
11430
11431 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11432 PyObject *resultobj = 0;
11433 wxZipFSHandler *result = 0 ;
11434
11435 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 result = (wxZipFSHandler *)new wxZipFSHandler();
11439 wxPyEndAllowThreads(__tstate);
11440 if (PyErr_Occurred()) SWIG_fail;
11441 }
11442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11443 return resultobj;
11444 fail:
11445 return NULL;
11446 }
11447
11448
11449 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11450 PyObject *resultobj = 0;
11451 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11452 wxString *arg2 = 0 ;
11453 bool result;
11454 void *argp1 = 0 ;
11455 int res1 = 0 ;
11456 bool temp2 = false ;
11457 PyObject * obj0 = 0 ;
11458 PyObject * obj1 = 0 ;
11459 char * kwnames[] = {
11460 (char *) "self",(char *) "location", NULL
11461 };
11462
11463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11465 if (!SWIG_IsOK(res1)) {
11466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11467 }
11468 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11469 {
11470 arg2 = wxString_in_helper(obj1);
11471 if (arg2 == NULL) SWIG_fail;
11472 temp2 = true;
11473 }
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11477 wxPyEndAllowThreads(__tstate);
11478 if (PyErr_Occurred()) SWIG_fail;
11479 }
11480 {
11481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11482 }
11483 {
11484 if (temp2)
11485 delete arg2;
11486 }
11487 return resultobj;
11488 fail:
11489 {
11490 if (temp2)
11491 delete arg2;
11492 }
11493 return NULL;
11494 }
11495
11496
11497 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11498 PyObject *resultobj = 0;
11499 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11500 wxFileSystem *arg2 = 0 ;
11501 wxString *arg3 = 0 ;
11502 wxFSFile *result = 0 ;
11503 void *argp1 = 0 ;
11504 int res1 = 0 ;
11505 void *argp2 = 0 ;
11506 int res2 = 0 ;
11507 bool temp3 = false ;
11508 PyObject * obj0 = 0 ;
11509 PyObject * obj1 = 0 ;
11510 PyObject * obj2 = 0 ;
11511 char * kwnames[] = {
11512 (char *) "self",(char *) "fs",(char *) "location", NULL
11513 };
11514
11515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11517 if (!SWIG_IsOK(res1)) {
11518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11519 }
11520 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11521 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11522 if (!SWIG_IsOK(res2)) {
11523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11524 }
11525 if (!argp2) {
11526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11527 }
11528 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11529 {
11530 arg3 = wxString_in_helper(obj2);
11531 if (arg3 == NULL) SWIG_fail;
11532 temp3 = true;
11533 }
11534 {
11535 PyThreadState* __tstate = wxPyBeginAllowThreads();
11536 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11537 wxPyEndAllowThreads(__tstate);
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 {
11541 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11542 }
11543 {
11544 if (temp3)
11545 delete arg3;
11546 }
11547 return resultobj;
11548 fail:
11549 {
11550 if (temp3)
11551 delete arg3;
11552 }
11553 return NULL;
11554 }
11555
11556
11557 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11558 PyObject *resultobj = 0;
11559 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11560 wxString *arg2 = 0 ;
11561 int arg3 = (int) 0 ;
11562 wxString result;
11563 void *argp1 = 0 ;
11564 int res1 = 0 ;
11565 bool temp2 = false ;
11566 int val3 ;
11567 int ecode3 = 0 ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 PyObject * obj2 = 0 ;
11571 char * kwnames[] = {
11572 (char *) "self",(char *) "spec",(char *) "flags", NULL
11573 };
11574
11575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11577 if (!SWIG_IsOK(res1)) {
11578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11579 }
11580 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11581 {
11582 arg2 = wxString_in_helper(obj1);
11583 if (arg2 == NULL) SWIG_fail;
11584 temp2 = true;
11585 }
11586 if (obj2) {
11587 ecode3 = SWIG_AsVal_int(obj2, &val3);
11588 if (!SWIG_IsOK(ecode3)) {
11589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11590 }
11591 arg3 = static_cast< int >(val3);
11592 }
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 {
11600 #if wxUSE_UNICODE
11601 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11602 #else
11603 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11604 #endif
11605 }
11606 {
11607 if (temp2)
11608 delete arg2;
11609 }
11610 return resultobj;
11611 fail:
11612 {
11613 if (temp2)
11614 delete arg2;
11615 }
11616 return NULL;
11617 }
11618
11619
11620 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11621 PyObject *resultobj = 0;
11622 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11623 wxString result;
11624 void *argp1 = 0 ;
11625 int res1 = 0 ;
11626 PyObject *swig_obj[1] ;
11627
11628 if (!args) SWIG_fail;
11629 swig_obj[0] = args;
11630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11631 if (!SWIG_IsOK(res1)) {
11632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11633 }
11634 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 result = (arg1)->FindNext();
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 {
11642 #if wxUSE_UNICODE
11643 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11644 #else
11645 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11646 #endif
11647 }
11648 return resultobj;
11649 fail:
11650 return NULL;
11651 }
11652
11653
11654 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11655 PyObject *obj;
11656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11657 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11658 return SWIG_Py_Void();
11659 }
11660
11661 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11662 return SWIG_Python_InitShadowInstance(args);
11663 }
11664
11665 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11666 PyObject *resultobj = 0;
11667 wxString *arg1 = 0 ;
11668 wxImage *arg2 = 0 ;
11669 long arg3 ;
11670 bool temp1 = false ;
11671 void *argp2 = 0 ;
11672 int res2 = 0 ;
11673 long val3 ;
11674 int ecode3 = 0 ;
11675 PyObject * obj0 = 0 ;
11676 PyObject * obj1 = 0 ;
11677 PyObject * obj2 = 0 ;
11678 char * kwnames[] = {
11679 (char *) "filename",(char *) "image",(char *) "type", NULL
11680 };
11681
11682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11683 {
11684 arg1 = wxString_in_helper(obj0);
11685 if (arg1 == NULL) SWIG_fail;
11686 temp1 = true;
11687 }
11688 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11689 if (!SWIG_IsOK(res2)) {
11690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11691 }
11692 if (!argp2) {
11693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11694 }
11695 arg2 = reinterpret_cast< wxImage * >(argp2);
11696 ecode3 = SWIG_AsVal_long(obj2, &val3);
11697 if (!SWIG_IsOK(ecode3)) {
11698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11699 }
11700 arg3 = static_cast< long >(val3);
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 resultobj = SWIG_Py_Void();
11708 {
11709 if (temp1)
11710 delete arg1;
11711 }
11712 return resultobj;
11713 fail:
11714 {
11715 if (temp1)
11716 delete arg1;
11717 }
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11723 PyObject *resultobj = 0;
11724 wxString *arg1 = 0 ;
11725 wxBitmap *arg2 = 0 ;
11726 long arg3 ;
11727 bool temp1 = false ;
11728 void *argp2 = 0 ;
11729 int res2 = 0 ;
11730 long val3 ;
11731 int ecode3 = 0 ;
11732 PyObject * obj0 = 0 ;
11733 PyObject * obj1 = 0 ;
11734 PyObject * obj2 = 0 ;
11735 char * kwnames[] = {
11736 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11737 };
11738
11739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11740 {
11741 arg1 = wxString_in_helper(obj0);
11742 if (arg1 == NULL) SWIG_fail;
11743 temp1 = true;
11744 }
11745 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11746 if (!SWIG_IsOK(res2)) {
11747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11748 }
11749 if (!argp2) {
11750 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11751 }
11752 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11753 ecode3 = SWIG_AsVal_long(obj2, &val3);
11754 if (!SWIG_IsOK(ecode3)) {
11755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11756 }
11757 arg3 = static_cast< long >(val3);
11758 {
11759 PyThreadState* __tstate = wxPyBeginAllowThreads();
11760 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 resultobj = SWIG_Py_Void();
11765 {
11766 if (temp1)
11767 delete arg1;
11768 }
11769 return resultobj;
11770 fail:
11771 {
11772 if (temp1)
11773 delete arg1;
11774 }
11775 return NULL;
11776 }
11777
11778
11779 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11780 PyObject *resultobj = 0;
11781 wxString *arg1 = 0 ;
11782 PyObject *arg2 = (PyObject *) 0 ;
11783 bool temp1 = false ;
11784 PyObject * obj0 = 0 ;
11785 PyObject * obj1 = 0 ;
11786 char * kwnames[] = {
11787 (char *) "filename",(char *) "data", NULL
11788 };
11789
11790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11791 {
11792 arg1 = wxString_in_helper(obj0);
11793 if (arg1 == NULL) SWIG_fail;
11794 temp1 = true;
11795 }
11796 arg2 = obj1;
11797 {
11798 PyThreadState* __tstate = wxPyBeginAllowThreads();
11799 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 resultobj = SWIG_Py_Void();
11804 {
11805 if (temp1)
11806 delete arg1;
11807 }
11808 return resultobj;
11809 fail:
11810 {
11811 if (temp1)
11812 delete arg1;
11813 }
11814 return NULL;
11815 }
11816
11817
11818 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11819 PyObject *resultobj = 0;
11820 wxMemoryFSHandler *result = 0 ;
11821
11822 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11823 {
11824 PyThreadState* __tstate = wxPyBeginAllowThreads();
11825 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11830 return resultobj;
11831 fail:
11832 return NULL;
11833 }
11834
11835
11836 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11837 PyObject *resultobj = 0;
11838 wxString *arg1 = 0 ;
11839 bool temp1 = false ;
11840 PyObject * obj0 = 0 ;
11841 char * kwnames[] = {
11842 (char *) "filename", NULL
11843 };
11844
11845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11846 {
11847 arg1 = wxString_in_helper(obj0);
11848 if (arg1 == NULL) SWIG_fail;
11849 temp1 = true;
11850 }
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 resultobj = SWIG_Py_Void();
11858 {
11859 if (temp1)
11860 delete arg1;
11861 }
11862 return resultobj;
11863 fail:
11864 {
11865 if (temp1)
11866 delete arg1;
11867 }
11868 return NULL;
11869 }
11870
11871
11872 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11873 PyObject *resultobj = 0;
11874 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11875 wxString *arg2 = 0 ;
11876 bool result;
11877 void *argp1 = 0 ;
11878 int res1 = 0 ;
11879 bool temp2 = false ;
11880 PyObject * obj0 = 0 ;
11881 PyObject * obj1 = 0 ;
11882 char * kwnames[] = {
11883 (char *) "self",(char *) "location", NULL
11884 };
11885
11886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11888 if (!SWIG_IsOK(res1)) {
11889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11890 }
11891 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11892 {
11893 arg2 = wxString_in_helper(obj1);
11894 if (arg2 == NULL) SWIG_fail;
11895 temp2 = true;
11896 }
11897 {
11898 PyThreadState* __tstate = wxPyBeginAllowThreads();
11899 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11900 wxPyEndAllowThreads(__tstate);
11901 if (PyErr_Occurred()) SWIG_fail;
11902 }
11903 {
11904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11905 }
11906 {
11907 if (temp2)
11908 delete arg2;
11909 }
11910 return resultobj;
11911 fail:
11912 {
11913 if (temp2)
11914 delete arg2;
11915 }
11916 return NULL;
11917 }
11918
11919
11920 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11921 PyObject *resultobj = 0;
11922 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11923 wxFileSystem *arg2 = 0 ;
11924 wxString *arg3 = 0 ;
11925 wxFSFile *result = 0 ;
11926 void *argp1 = 0 ;
11927 int res1 = 0 ;
11928 void *argp2 = 0 ;
11929 int res2 = 0 ;
11930 bool temp3 = false ;
11931 PyObject * obj0 = 0 ;
11932 PyObject * obj1 = 0 ;
11933 PyObject * obj2 = 0 ;
11934 char * kwnames[] = {
11935 (char *) "self",(char *) "fs",(char *) "location", NULL
11936 };
11937
11938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11940 if (!SWIG_IsOK(res1)) {
11941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11942 }
11943 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11944 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11945 if (!SWIG_IsOK(res2)) {
11946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11947 }
11948 if (!argp2) {
11949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11950 }
11951 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11952 {
11953 arg3 = wxString_in_helper(obj2);
11954 if (arg3 == NULL) SWIG_fail;
11955 temp3 = true;
11956 }
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11960 wxPyEndAllowThreads(__tstate);
11961 if (PyErr_Occurred()) SWIG_fail;
11962 }
11963 {
11964 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11965 }
11966 {
11967 if (temp3)
11968 delete arg3;
11969 }
11970 return resultobj;
11971 fail:
11972 {
11973 if (temp3)
11974 delete arg3;
11975 }
11976 return NULL;
11977 }
11978
11979
11980 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11981 PyObject *resultobj = 0;
11982 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11983 wxString *arg2 = 0 ;
11984 int arg3 = (int) 0 ;
11985 wxString result;
11986 void *argp1 = 0 ;
11987 int res1 = 0 ;
11988 bool temp2 = false ;
11989 int val3 ;
11990 int ecode3 = 0 ;
11991 PyObject * obj0 = 0 ;
11992 PyObject * obj1 = 0 ;
11993 PyObject * obj2 = 0 ;
11994 char * kwnames[] = {
11995 (char *) "self",(char *) "spec",(char *) "flags", NULL
11996 };
11997
11998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12000 if (!SWIG_IsOK(res1)) {
12001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12002 }
12003 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12004 {
12005 arg2 = wxString_in_helper(obj1);
12006 if (arg2 == NULL) SWIG_fail;
12007 temp2 = true;
12008 }
12009 if (obj2) {
12010 ecode3 = SWIG_AsVal_int(obj2, &val3);
12011 if (!SWIG_IsOK(ecode3)) {
12012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12013 }
12014 arg3 = static_cast< int >(val3);
12015 }
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 {
12023 #if wxUSE_UNICODE
12024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12025 #else
12026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12027 #endif
12028 }
12029 {
12030 if (temp2)
12031 delete arg2;
12032 }
12033 return resultobj;
12034 fail:
12035 {
12036 if (temp2)
12037 delete arg2;
12038 }
12039 return NULL;
12040 }
12041
12042
12043 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12044 PyObject *resultobj = 0;
12045 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12046 wxString result;
12047 void *argp1 = 0 ;
12048 int res1 = 0 ;
12049 PyObject *swig_obj[1] ;
12050
12051 if (!args) SWIG_fail;
12052 swig_obj[0] = args;
12053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12054 if (!SWIG_IsOK(res1)) {
12055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12056 }
12057 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 result = (arg1)->FindNext();
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 {
12065 #if wxUSE_UNICODE
12066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12067 #else
12068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12069 #endif
12070 }
12071 return resultobj;
12072 fail:
12073 return NULL;
12074 }
12075
12076
12077 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12078 PyObject *obj;
12079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12080 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12081 return SWIG_Py_Void();
12082 }
12083
12084 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12085 return SWIG_Python_InitShadowInstance(args);
12086 }
12087
12088 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12089 PyObject *resultobj = 0;
12090 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12091 wxString result;
12092 void *argp1 = 0 ;
12093 int res1 = 0 ;
12094 PyObject *swig_obj[1] ;
12095
12096 if (!args) SWIG_fail;
12097 swig_obj[0] = args;
12098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12099 if (!SWIG_IsOK(res1)) {
12100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12101 }
12102 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 result = (arg1)->GetName();
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 {
12110 #if wxUSE_UNICODE
12111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12112 #else
12113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12114 #endif
12115 }
12116 return resultobj;
12117 fail:
12118 return NULL;
12119 }
12120
12121
12122 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12123 PyObject *resultobj = 0;
12124 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12125 wxString result;
12126 void *argp1 = 0 ;
12127 int res1 = 0 ;
12128 PyObject *swig_obj[1] ;
12129
12130 if (!args) SWIG_fail;
12131 swig_obj[0] = args;
12132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12133 if (!SWIG_IsOK(res1)) {
12134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12135 }
12136 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12137 {
12138 PyThreadState* __tstate = wxPyBeginAllowThreads();
12139 result = (arg1)->GetExtension();
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 #if wxUSE_UNICODE
12145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12146 #else
12147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12148 #endif
12149 }
12150 return resultobj;
12151 fail:
12152 return NULL;
12153 }
12154
12155
12156 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12157 PyObject *resultobj = 0;
12158 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12159 long result;
12160 void *argp1 = 0 ;
12161 int res1 = 0 ;
12162 PyObject *swig_obj[1] ;
12163
12164 if (!args) SWIG_fail;
12165 swig_obj[0] = args;
12166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12167 if (!SWIG_IsOK(res1)) {
12168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12169 }
12170 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 result = (long)(arg1)->GetType();
12174 wxPyEndAllowThreads(__tstate);
12175 if (PyErr_Occurred()) SWIG_fail;
12176 }
12177 resultobj = SWIG_From_long(static_cast< long >(result));
12178 return resultobj;
12179 fail:
12180 return NULL;
12181 }
12182
12183
12184 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12185 PyObject *resultobj = 0;
12186 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12187 wxString result;
12188 void *argp1 = 0 ;
12189 int res1 = 0 ;
12190 PyObject *swig_obj[1] ;
12191
12192 if (!args) SWIG_fail;
12193 swig_obj[0] = args;
12194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12195 if (!SWIG_IsOK(res1)) {
12196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12197 }
12198 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12199 {
12200 PyThreadState* __tstate = wxPyBeginAllowThreads();
12201 result = (arg1)->GetMimeType();
12202 wxPyEndAllowThreads(__tstate);
12203 if (PyErr_Occurred()) SWIG_fail;
12204 }
12205 {
12206 #if wxUSE_UNICODE
12207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12208 #else
12209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12210 #endif
12211 }
12212 return resultobj;
12213 fail:
12214 return NULL;
12215 }
12216
12217
12218 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12219 PyObject *resultobj = 0;
12220 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12221 wxString *arg2 = 0 ;
12222 bool result;
12223 void *argp1 = 0 ;
12224 int res1 = 0 ;
12225 bool temp2 = false ;
12226 PyObject * obj0 = 0 ;
12227 PyObject * obj1 = 0 ;
12228 char * kwnames[] = {
12229 (char *) "self",(char *) "name", NULL
12230 };
12231
12232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12234 if (!SWIG_IsOK(res1)) {
12235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12236 }
12237 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12238 {
12239 arg2 = wxString_in_helper(obj1);
12240 if (arg2 == NULL) SWIG_fail;
12241 temp2 = true;
12242 }
12243 {
12244 PyThreadState* __tstate = wxPyBeginAllowThreads();
12245 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12246 wxPyEndAllowThreads(__tstate);
12247 if (PyErr_Occurred()) SWIG_fail;
12248 }
12249 {
12250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12251 }
12252 {
12253 if (temp2)
12254 delete arg2;
12255 }
12256 return resultobj;
12257 fail:
12258 {
12259 if (temp2)
12260 delete arg2;
12261 }
12262 return NULL;
12263 }
12264
12265
12266 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12267 PyObject *resultobj = 0;
12268 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12269 wxInputStream *arg2 = 0 ;
12270 bool result;
12271 void *argp1 = 0 ;
12272 int res1 = 0 ;
12273 wxPyInputStream *temp2 ;
12274 bool created2 ;
12275 PyObject * obj0 = 0 ;
12276 PyObject * obj1 = 0 ;
12277 char * kwnames[] = {
12278 (char *) "self",(char *) "stream", NULL
12279 };
12280
12281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12283 if (!SWIG_IsOK(res1)) {
12284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12285 }
12286 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12287 {
12288 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12289 arg2 = temp2->m_wxis;
12290 created2 = false;
12291 } else {
12292 PyErr_Clear(); // clear the failure of the wxPyConvert above
12293 arg2 = wxPyCBInputStream_create(obj1, false);
12294 if (arg2 == NULL) {
12295 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12296 SWIG_fail;
12297 }
12298 created2 = true;
12299 }
12300 }
12301 {
12302 PyThreadState* __tstate = wxPyBeginAllowThreads();
12303 result = (bool)(arg1)->CanRead(*arg2);
12304 wxPyEndAllowThreads(__tstate);
12305 if (PyErr_Occurred()) SWIG_fail;
12306 }
12307 {
12308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12309 }
12310 {
12311 if (created2) delete arg2;
12312 }
12313 return resultobj;
12314 fail:
12315 {
12316 if (created2) delete arg2;
12317 }
12318 return NULL;
12319 }
12320
12321
12322 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12323 PyObject *resultobj = 0;
12324 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12325 wxString *arg2 = 0 ;
12326 void *argp1 = 0 ;
12327 int res1 = 0 ;
12328 bool temp2 = false ;
12329 PyObject * obj0 = 0 ;
12330 PyObject * obj1 = 0 ;
12331 char * kwnames[] = {
12332 (char *) "self",(char *) "name", NULL
12333 };
12334
12335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12337 if (!SWIG_IsOK(res1)) {
12338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12339 }
12340 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12341 {
12342 arg2 = wxString_in_helper(obj1);
12343 if (arg2 == NULL) SWIG_fail;
12344 temp2 = true;
12345 }
12346 {
12347 PyThreadState* __tstate = wxPyBeginAllowThreads();
12348 (arg1)->SetName((wxString const &)*arg2);
12349 wxPyEndAllowThreads(__tstate);
12350 if (PyErr_Occurred()) SWIG_fail;
12351 }
12352 resultobj = SWIG_Py_Void();
12353 {
12354 if (temp2)
12355 delete arg2;
12356 }
12357 return resultobj;
12358 fail:
12359 {
12360 if (temp2)
12361 delete arg2;
12362 }
12363 return NULL;
12364 }
12365
12366
12367 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12368 PyObject *resultobj = 0;
12369 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12370 wxString *arg2 = 0 ;
12371 void *argp1 = 0 ;
12372 int res1 = 0 ;
12373 bool temp2 = false ;
12374 PyObject * obj0 = 0 ;
12375 PyObject * obj1 = 0 ;
12376 char * kwnames[] = {
12377 (char *) "self",(char *) "extension", NULL
12378 };
12379
12380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12382 if (!SWIG_IsOK(res1)) {
12383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12384 }
12385 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12386 {
12387 arg2 = wxString_in_helper(obj1);
12388 if (arg2 == NULL) SWIG_fail;
12389 temp2 = true;
12390 }
12391 {
12392 PyThreadState* __tstate = wxPyBeginAllowThreads();
12393 (arg1)->SetExtension((wxString const &)*arg2);
12394 wxPyEndAllowThreads(__tstate);
12395 if (PyErr_Occurred()) SWIG_fail;
12396 }
12397 resultobj = SWIG_Py_Void();
12398 {
12399 if (temp2)
12400 delete arg2;
12401 }
12402 return resultobj;
12403 fail:
12404 {
12405 if (temp2)
12406 delete arg2;
12407 }
12408 return NULL;
12409 }
12410
12411
12412 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12413 PyObject *resultobj = 0;
12414 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12415 long arg2 ;
12416 void *argp1 = 0 ;
12417 int res1 = 0 ;
12418 long val2 ;
12419 int ecode2 = 0 ;
12420 PyObject * obj0 = 0 ;
12421 PyObject * obj1 = 0 ;
12422 char * kwnames[] = {
12423 (char *) "self",(char *) "type", NULL
12424 };
12425
12426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12428 if (!SWIG_IsOK(res1)) {
12429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12430 }
12431 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12432 ecode2 = SWIG_AsVal_long(obj1, &val2);
12433 if (!SWIG_IsOK(ecode2)) {
12434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12435 }
12436 arg2 = static_cast< long >(val2);
12437 {
12438 PyThreadState* __tstate = wxPyBeginAllowThreads();
12439 (arg1)->SetType(arg2);
12440 wxPyEndAllowThreads(__tstate);
12441 if (PyErr_Occurred()) SWIG_fail;
12442 }
12443 resultobj = SWIG_Py_Void();
12444 return resultobj;
12445 fail:
12446 return NULL;
12447 }
12448
12449
12450 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj = 0;
12452 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12453 wxString *arg2 = 0 ;
12454 void *argp1 = 0 ;
12455 int res1 = 0 ;
12456 bool temp2 = false ;
12457 PyObject * obj0 = 0 ;
12458 PyObject * obj1 = 0 ;
12459 char * kwnames[] = {
12460 (char *) "self",(char *) "mimetype", NULL
12461 };
12462
12463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12465 if (!SWIG_IsOK(res1)) {
12466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12467 }
12468 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12469 {
12470 arg2 = wxString_in_helper(obj1);
12471 if (arg2 == NULL) SWIG_fail;
12472 temp2 = true;
12473 }
12474 {
12475 PyThreadState* __tstate = wxPyBeginAllowThreads();
12476 (arg1)->SetMimeType((wxString const &)*arg2);
12477 wxPyEndAllowThreads(__tstate);
12478 if (PyErr_Occurred()) SWIG_fail;
12479 }
12480 resultobj = SWIG_Py_Void();
12481 {
12482 if (temp2)
12483 delete arg2;
12484 }
12485 return resultobj;
12486 fail:
12487 {
12488 if (temp2)
12489 delete arg2;
12490 }
12491 return NULL;
12492 }
12493
12494
12495 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496 PyObject *obj;
12497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12498 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12499 return SWIG_Py_Void();
12500 }
12501
12502 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12503 PyObject *resultobj = 0;
12504 wxPyImageHandler *result = 0 ;
12505
12506 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12507 {
12508 PyThreadState* __tstate = wxPyBeginAllowThreads();
12509 result = (wxPyImageHandler *)new wxPyImageHandler();
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12514 return resultobj;
12515 fail:
12516 return NULL;
12517 }
12518
12519
12520 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj = 0;
12522 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12523 PyObject *arg2 = (PyObject *) 0 ;
12524 void *argp1 = 0 ;
12525 int res1 = 0 ;
12526 PyObject * obj0 = 0 ;
12527 PyObject * obj1 = 0 ;
12528 char * kwnames[] = {
12529 (char *) "self",(char *) "self", NULL
12530 };
12531
12532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12534 if (!SWIG_IsOK(res1)) {
12535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12536 }
12537 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12538 arg2 = obj1;
12539 {
12540 PyThreadState* __tstate = wxPyBeginAllowThreads();
12541 (arg1)->_SetSelf(arg2);
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 resultobj = SWIG_Py_Void();
12546 return resultobj;
12547 fail:
12548 return NULL;
12549 }
12550
12551
12552 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12553 PyObject *obj;
12554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12555 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12556 return SWIG_Py_Void();
12557 }
12558
12559 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12560 return SWIG_Python_InitShadowInstance(args);
12561 }
12562
12563 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12564 PyObject *resultobj = 0;
12565 wxImageHistogram *result = 0 ;
12566
12567 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12568 {
12569 PyThreadState* __tstate = wxPyBeginAllowThreads();
12570 result = (wxImageHistogram *)new wxImageHistogram();
12571 wxPyEndAllowThreads(__tstate);
12572 if (PyErr_Occurred()) SWIG_fail;
12573 }
12574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12575 return resultobj;
12576 fail:
12577 return NULL;
12578 }
12579
12580
12581 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj = 0;
12583 byte arg1 ;
12584 byte arg2 ;
12585 byte arg3 ;
12586 unsigned long result;
12587 unsigned char val1 ;
12588 int ecode1 = 0 ;
12589 unsigned char val2 ;
12590 int ecode2 = 0 ;
12591 unsigned char val3 ;
12592 int ecode3 = 0 ;
12593 PyObject * obj0 = 0 ;
12594 PyObject * obj1 = 0 ;
12595 PyObject * obj2 = 0 ;
12596 char * kwnames[] = {
12597 (char *) "r",(char *) "g",(char *) "b", NULL
12598 };
12599
12600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12601 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12602 if (!SWIG_IsOK(ecode1)) {
12603 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12604 }
12605 arg1 = static_cast< byte >(val1);
12606 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12607 if (!SWIG_IsOK(ecode2)) {
12608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12609 }
12610 arg2 = static_cast< byte >(val2);
12611 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12612 if (!SWIG_IsOK(ecode3)) {
12613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12614 }
12615 arg3 = static_cast< byte >(val3);
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12619 wxPyEndAllowThreads(__tstate);
12620 if (PyErr_Occurred()) SWIG_fail;
12621 }
12622 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12623 return resultobj;
12624 fail:
12625 return NULL;
12626 }
12627
12628
12629 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12630 PyObject *resultobj = 0;
12631 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12632 byte *arg2 = (byte *) 0 ;
12633 byte *arg3 = (byte *) 0 ;
12634 byte *arg4 = (byte *) 0 ;
12635 byte arg5 = (byte) 1 ;
12636 byte arg6 = (byte) 0 ;
12637 byte arg7 = (byte) 0 ;
12638 bool result;
12639 void *argp1 = 0 ;
12640 int res1 = 0 ;
12641 byte temp2 ;
12642 int res2 = SWIG_TMPOBJ ;
12643 byte temp3 ;
12644 int res3 = SWIG_TMPOBJ ;
12645 byte temp4 ;
12646 int res4 = SWIG_TMPOBJ ;
12647 unsigned char val5 ;
12648 int ecode5 = 0 ;
12649 unsigned char val6 ;
12650 int ecode6 = 0 ;
12651 unsigned char val7 ;
12652 int ecode7 = 0 ;
12653 PyObject * obj0 = 0 ;
12654 PyObject * obj1 = 0 ;
12655 PyObject * obj2 = 0 ;
12656 PyObject * obj3 = 0 ;
12657 char * kwnames[] = {
12658 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12659 };
12660
12661 arg2 = &temp2;
12662 arg3 = &temp3;
12663 arg4 = &temp4;
12664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12666 if (!SWIG_IsOK(res1)) {
12667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12668 }
12669 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12670 if (obj1) {
12671 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12672 if (!SWIG_IsOK(ecode5)) {
12673 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12674 }
12675 arg5 = static_cast< byte >(val5);
12676 }
12677 if (obj2) {
12678 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12679 if (!SWIG_IsOK(ecode6)) {
12680 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12681 }
12682 arg6 = static_cast< byte >(val6);
12683 }
12684 if (obj3) {
12685 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12686 if (!SWIG_IsOK(ecode7)) {
12687 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12688 }
12689 arg7 = static_cast< byte >(val7);
12690 }
12691 {
12692 PyThreadState* __tstate = wxPyBeginAllowThreads();
12693 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12694 wxPyEndAllowThreads(__tstate);
12695 if (PyErr_Occurred()) SWIG_fail;
12696 }
12697 {
12698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12699 }
12700 if (SWIG_IsTmpObj(res2)) {
12701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12702 } else {
12703 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12705 }
12706 if (SWIG_IsTmpObj(res3)) {
12707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12708 } else {
12709 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12711 }
12712 if (SWIG_IsTmpObj(res4)) {
12713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12714 } else {
12715 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12717 }
12718 return resultobj;
12719 fail:
12720 return NULL;
12721 }
12722
12723
12724 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12725 PyObject *resultobj = 0;
12726 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12727 unsigned long arg2 ;
12728 unsigned long result;
12729 void *argp1 = 0 ;
12730 int res1 = 0 ;
12731 unsigned long val2 ;
12732 int ecode2 = 0 ;
12733 PyObject * obj0 = 0 ;
12734 PyObject * obj1 = 0 ;
12735 char * kwnames[] = {
12736 (char *) "self",(char *) "key", NULL
12737 };
12738
12739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12741 if (!SWIG_IsOK(res1)) {
12742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12743 }
12744 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12745 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12746 if (!SWIG_IsOK(ecode2)) {
12747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12748 }
12749 arg2 = static_cast< unsigned long >(val2);
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12764 PyObject *resultobj = 0;
12765 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12766 byte arg2 ;
12767 byte arg3 ;
12768 byte arg4 ;
12769 unsigned long result;
12770 void *argp1 = 0 ;
12771 int res1 = 0 ;
12772 unsigned char val2 ;
12773 int ecode2 = 0 ;
12774 unsigned char val3 ;
12775 int ecode3 = 0 ;
12776 unsigned char val4 ;
12777 int ecode4 = 0 ;
12778 PyObject * obj0 = 0 ;
12779 PyObject * obj1 = 0 ;
12780 PyObject * obj2 = 0 ;
12781 PyObject * obj3 = 0 ;
12782 char * kwnames[] = {
12783 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12784 };
12785
12786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12788 if (!SWIG_IsOK(res1)) {
12789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12790 }
12791 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12792 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12793 if (!SWIG_IsOK(ecode2)) {
12794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12795 }
12796 arg2 = static_cast< byte >(val2);
12797 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12798 if (!SWIG_IsOK(ecode3)) {
12799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12800 }
12801 arg3 = static_cast< byte >(val3);
12802 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12803 if (!SWIG_IsOK(ecode4)) {
12804 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12805 }
12806 arg4 = static_cast< byte >(val4);
12807 {
12808 PyThreadState* __tstate = wxPyBeginAllowThreads();
12809 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12810 wxPyEndAllowThreads(__tstate);
12811 if (PyErr_Occurred()) SWIG_fail;
12812 }
12813 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12814 return resultobj;
12815 fail:
12816 return NULL;
12817 }
12818
12819
12820 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12821 PyObject *resultobj = 0;
12822 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12823 wxColour *arg2 = 0 ;
12824 unsigned long result;
12825 void *argp1 = 0 ;
12826 int res1 = 0 ;
12827 wxColour temp2 ;
12828 PyObject * obj0 = 0 ;
12829 PyObject * obj1 = 0 ;
12830 char * kwnames[] = {
12831 (char *) "self",(char *) "colour", NULL
12832 };
12833
12834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12836 if (!SWIG_IsOK(res1)) {
12837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12838 }
12839 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12840 {
12841 arg2 = &temp2;
12842 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12843 }
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12851 return resultobj;
12852 fail:
12853 return NULL;
12854 }
12855
12856
12857 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12858 PyObject *obj;
12859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12860 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12861 return SWIG_Py_Void();
12862 }
12863
12864 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12865 return SWIG_Python_InitShadowInstance(args);
12866 }
12867
12868 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12869 PyObject *resultobj = 0;
12870 byte arg1 = (byte) 0 ;
12871 byte arg2 = (byte) 0 ;
12872 byte arg3 = (byte) 0 ;
12873 wxImage_RGBValue *result = 0 ;
12874 unsigned char val1 ;
12875 int ecode1 = 0 ;
12876 unsigned char val2 ;
12877 int ecode2 = 0 ;
12878 unsigned char val3 ;
12879 int ecode3 = 0 ;
12880 PyObject * obj0 = 0 ;
12881 PyObject * obj1 = 0 ;
12882 PyObject * obj2 = 0 ;
12883 char * kwnames[] = {
12884 (char *) "r",(char *) "g",(char *) "b", NULL
12885 };
12886
12887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12888 if (obj0) {
12889 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12890 if (!SWIG_IsOK(ecode1)) {
12891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12892 }
12893 arg1 = static_cast< byte >(val1);
12894 }
12895 if (obj1) {
12896 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12897 if (!SWIG_IsOK(ecode2)) {
12898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12899 }
12900 arg2 = static_cast< byte >(val2);
12901 }
12902 if (obj2) {
12903 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12904 if (!SWIG_IsOK(ecode3)) {
12905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12906 }
12907 arg3 = static_cast< byte >(val3);
12908 }
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12912 wxPyEndAllowThreads(__tstate);
12913 if (PyErr_Occurred()) SWIG_fail;
12914 }
12915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12916 return resultobj;
12917 fail:
12918 return NULL;
12919 }
12920
12921
12922 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12923 PyObject *resultobj = 0;
12924 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12925 byte arg2 ;
12926 void *argp1 = 0 ;
12927 int res1 = 0 ;
12928 unsigned char val2 ;
12929 int ecode2 = 0 ;
12930 PyObject *swig_obj[2] ;
12931
12932 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12934 if (!SWIG_IsOK(res1)) {
12935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12936 }
12937 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12938 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12939 if (!SWIG_IsOK(ecode2)) {
12940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12941 }
12942 arg2 = static_cast< byte >(val2);
12943 if (arg1) (arg1)->red = arg2;
12944
12945 resultobj = SWIG_Py_Void();
12946 return resultobj;
12947 fail:
12948 return NULL;
12949 }
12950
12951
12952 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12953 PyObject *resultobj = 0;
12954 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12955 byte result;
12956 void *argp1 = 0 ;
12957 int res1 = 0 ;
12958 PyObject *swig_obj[1] ;
12959
12960 if (!args) SWIG_fail;
12961 swig_obj[0] = args;
12962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12963 if (!SWIG_IsOK(res1)) {
12964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12965 }
12966 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12967 result = (byte) ((arg1)->red);
12968 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976 PyObject *resultobj = 0;
12977 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12978 byte arg2 ;
12979 void *argp1 = 0 ;
12980 int res1 = 0 ;
12981 unsigned char val2 ;
12982 int ecode2 = 0 ;
12983 PyObject *swig_obj[2] ;
12984
12985 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12987 if (!SWIG_IsOK(res1)) {
12988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12989 }
12990 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12991 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12992 if (!SWIG_IsOK(ecode2)) {
12993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12994 }
12995 arg2 = static_cast< byte >(val2);
12996 if (arg1) (arg1)->green = arg2;
12997
12998 resultobj = SWIG_Py_Void();
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13006 PyObject *resultobj = 0;
13007 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13008 byte result;
13009 void *argp1 = 0 ;
13010 int res1 = 0 ;
13011 PyObject *swig_obj[1] ;
13012
13013 if (!args) SWIG_fail;
13014 swig_obj[0] = args;
13015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13016 if (!SWIG_IsOK(res1)) {
13017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13018 }
13019 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13020 result = (byte) ((arg1)->green);
13021 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13022 return resultobj;
13023 fail:
13024 return NULL;
13025 }
13026
13027
13028 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13029 PyObject *resultobj = 0;
13030 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13031 byte arg2 ;
13032 void *argp1 = 0 ;
13033 int res1 = 0 ;
13034 unsigned char val2 ;
13035 int ecode2 = 0 ;
13036 PyObject *swig_obj[2] ;
13037
13038 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13040 if (!SWIG_IsOK(res1)) {
13041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13042 }
13043 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13044 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13045 if (!SWIG_IsOK(ecode2)) {
13046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13047 }
13048 arg2 = static_cast< byte >(val2);
13049 if (arg1) (arg1)->blue = arg2;
13050
13051 resultobj = SWIG_Py_Void();
13052 return resultobj;
13053 fail:
13054 return NULL;
13055 }
13056
13057
13058 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13059 PyObject *resultobj = 0;
13060 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13061 byte result;
13062 void *argp1 = 0 ;
13063 int res1 = 0 ;
13064 PyObject *swig_obj[1] ;
13065
13066 if (!args) SWIG_fail;
13067 swig_obj[0] = args;
13068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13069 if (!SWIG_IsOK(res1)) {
13070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13071 }
13072 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13073 result = (byte) ((arg1)->blue);
13074 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13075 return resultobj;
13076 fail:
13077 return NULL;
13078 }
13079
13080
13081 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13082 PyObject *obj;
13083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13084 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13085 return SWIG_Py_Void();
13086 }
13087
13088 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13089 return SWIG_Python_InitShadowInstance(args);
13090 }
13091
13092 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13093 PyObject *resultobj = 0;
13094 double arg1 = (double) 0.0 ;
13095 double arg2 = (double) 0.0 ;
13096 double arg3 = (double) 0.0 ;
13097 wxImage_HSVValue *result = 0 ;
13098 double val1 ;
13099 int ecode1 = 0 ;
13100 double val2 ;
13101 int ecode2 = 0 ;
13102 double val3 ;
13103 int ecode3 = 0 ;
13104 PyObject * obj0 = 0 ;
13105 PyObject * obj1 = 0 ;
13106 PyObject * obj2 = 0 ;
13107 char * kwnames[] = {
13108 (char *) "h",(char *) "s",(char *) "v", NULL
13109 };
13110
13111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13112 if (obj0) {
13113 ecode1 = SWIG_AsVal_double(obj0, &val1);
13114 if (!SWIG_IsOK(ecode1)) {
13115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13116 }
13117 arg1 = static_cast< double >(val1);
13118 }
13119 if (obj1) {
13120 ecode2 = SWIG_AsVal_double(obj1, &val2);
13121 if (!SWIG_IsOK(ecode2)) {
13122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13123 }
13124 arg2 = static_cast< double >(val2);
13125 }
13126 if (obj2) {
13127 ecode3 = SWIG_AsVal_double(obj2, &val3);
13128 if (!SWIG_IsOK(ecode3)) {
13129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13130 }
13131 arg3 = static_cast< double >(val3);
13132 }
13133 {
13134 PyThreadState* __tstate = wxPyBeginAllowThreads();
13135 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13140 return resultobj;
13141 fail:
13142 return NULL;
13143 }
13144
13145
13146 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13147 PyObject *resultobj = 0;
13148 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13149 double arg2 ;
13150 void *argp1 = 0 ;
13151 int res1 = 0 ;
13152 double val2 ;
13153 int ecode2 = 0 ;
13154 PyObject *swig_obj[2] ;
13155
13156 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13158 if (!SWIG_IsOK(res1)) {
13159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13160 }
13161 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13162 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13163 if (!SWIG_IsOK(ecode2)) {
13164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13165 }
13166 arg2 = static_cast< double >(val2);
13167 if (arg1) (arg1)->hue = arg2;
13168
13169 resultobj = SWIG_Py_Void();
13170 return resultobj;
13171 fail:
13172 return NULL;
13173 }
13174
13175
13176 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13177 PyObject *resultobj = 0;
13178 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13179 double result;
13180 void *argp1 = 0 ;
13181 int res1 = 0 ;
13182 PyObject *swig_obj[1] ;
13183
13184 if (!args) SWIG_fail;
13185 swig_obj[0] = args;
13186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13187 if (!SWIG_IsOK(res1)) {
13188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13189 }
13190 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13191 result = (double) ((arg1)->hue);
13192 resultobj = SWIG_From_double(static_cast< double >(result));
13193 return resultobj;
13194 fail:
13195 return NULL;
13196 }
13197
13198
13199 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13200 PyObject *resultobj = 0;
13201 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13202 double arg2 ;
13203 void *argp1 = 0 ;
13204 int res1 = 0 ;
13205 double val2 ;
13206 int ecode2 = 0 ;
13207 PyObject *swig_obj[2] ;
13208
13209 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13211 if (!SWIG_IsOK(res1)) {
13212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13213 }
13214 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13215 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13216 if (!SWIG_IsOK(ecode2)) {
13217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13218 }
13219 arg2 = static_cast< double >(val2);
13220 if (arg1) (arg1)->saturation = arg2;
13221
13222 resultobj = SWIG_Py_Void();
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13230 PyObject *resultobj = 0;
13231 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13232 double result;
13233 void *argp1 = 0 ;
13234 int res1 = 0 ;
13235 PyObject *swig_obj[1] ;
13236
13237 if (!args) SWIG_fail;
13238 swig_obj[0] = args;
13239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13240 if (!SWIG_IsOK(res1)) {
13241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13242 }
13243 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13244 result = (double) ((arg1)->saturation);
13245 resultobj = SWIG_From_double(static_cast< double >(result));
13246 return resultobj;
13247 fail:
13248 return NULL;
13249 }
13250
13251
13252 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13253 PyObject *resultobj = 0;
13254 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13255 double arg2 ;
13256 void *argp1 = 0 ;
13257 int res1 = 0 ;
13258 double val2 ;
13259 int ecode2 = 0 ;
13260 PyObject *swig_obj[2] ;
13261
13262 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13264 if (!SWIG_IsOK(res1)) {
13265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13266 }
13267 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13268 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13269 if (!SWIG_IsOK(ecode2)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13271 }
13272 arg2 = static_cast< double >(val2);
13273 if (arg1) (arg1)->value = arg2;
13274
13275 resultobj = SWIG_Py_Void();
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13283 PyObject *resultobj = 0;
13284 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13285 double result;
13286 void *argp1 = 0 ;
13287 int res1 = 0 ;
13288 PyObject *swig_obj[1] ;
13289
13290 if (!args) SWIG_fail;
13291 swig_obj[0] = args;
13292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13293 if (!SWIG_IsOK(res1)) {
13294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13295 }
13296 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13297 result = (double) ((arg1)->value);
13298 resultobj = SWIG_From_double(static_cast< double >(result));
13299 return resultobj;
13300 fail:
13301 return NULL;
13302 }
13303
13304
13305 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13306 PyObject *obj;
13307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13308 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13309 return SWIG_Py_Void();
13310 }
13311
13312 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13313 return SWIG_Python_InitShadowInstance(args);
13314 }
13315
13316 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13317 PyObject *resultobj = 0;
13318 wxString *arg1 = 0 ;
13319 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13320 int arg3 = (int) -1 ;
13321 wxImage *result = 0 ;
13322 bool temp1 = false ;
13323 long val2 ;
13324 int ecode2 = 0 ;
13325 int val3 ;
13326 int ecode3 = 0 ;
13327 PyObject * obj0 = 0 ;
13328 PyObject * obj1 = 0 ;
13329 PyObject * obj2 = 0 ;
13330 char * kwnames[] = {
13331 (char *) "name",(char *) "type",(char *) "index", NULL
13332 };
13333
13334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13335 {
13336 arg1 = wxString_in_helper(obj0);
13337 if (arg1 == NULL) SWIG_fail;
13338 temp1 = true;
13339 }
13340 if (obj1) {
13341 ecode2 = SWIG_AsVal_long(obj1, &val2);
13342 if (!SWIG_IsOK(ecode2)) {
13343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13344 }
13345 arg2 = static_cast< long >(val2);
13346 }
13347 if (obj2) {
13348 ecode3 = SWIG_AsVal_int(obj2, &val3);
13349 if (!SWIG_IsOK(ecode3)) {
13350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13351 }
13352 arg3 = static_cast< int >(val3);
13353 }
13354 {
13355 PyThreadState* __tstate = wxPyBeginAllowThreads();
13356 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13361 {
13362 if (temp1)
13363 delete arg1;
13364 }
13365 return resultobj;
13366 fail:
13367 {
13368 if (temp1)
13369 delete arg1;
13370 }
13371 return NULL;
13372 }
13373
13374
13375 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13376 PyObject *resultobj = 0;
13377 wxImage *arg1 = (wxImage *) 0 ;
13378 void *argp1 = 0 ;
13379 int res1 = 0 ;
13380 PyObject *swig_obj[1] ;
13381
13382 if (!args) SWIG_fail;
13383 swig_obj[0] = args;
13384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13385 if (!SWIG_IsOK(res1)) {
13386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13387 }
13388 arg1 = reinterpret_cast< wxImage * >(argp1);
13389 {
13390 PyThreadState* __tstate = wxPyBeginAllowThreads();
13391 delete arg1;
13392
13393 wxPyEndAllowThreads(__tstate);
13394 if (PyErr_Occurred()) SWIG_fail;
13395 }
13396 resultobj = SWIG_Py_Void();
13397 return resultobj;
13398 fail:
13399 return NULL;
13400 }
13401
13402
13403 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13404 PyObject *resultobj = 0;
13405 wxString *arg1 = 0 ;
13406 wxString *arg2 = 0 ;
13407 int arg3 = (int) -1 ;
13408 wxImage *result = 0 ;
13409 bool temp1 = false ;
13410 bool temp2 = false ;
13411 int val3 ;
13412 int ecode3 = 0 ;
13413 PyObject * obj0 = 0 ;
13414 PyObject * obj1 = 0 ;
13415 PyObject * obj2 = 0 ;
13416 char * kwnames[] = {
13417 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13418 };
13419
13420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13421 {
13422 arg1 = wxString_in_helper(obj0);
13423 if (arg1 == NULL) SWIG_fail;
13424 temp1 = true;
13425 }
13426 {
13427 arg2 = wxString_in_helper(obj1);
13428 if (arg2 == NULL) SWIG_fail;
13429 temp2 = true;
13430 }
13431 if (obj2) {
13432 ecode3 = SWIG_AsVal_int(obj2, &val3);
13433 if (!SWIG_IsOK(ecode3)) {
13434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13435 }
13436 arg3 = static_cast< int >(val3);
13437 }
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13445 {
13446 if (temp1)
13447 delete arg1;
13448 }
13449 {
13450 if (temp2)
13451 delete arg2;
13452 }
13453 return resultobj;
13454 fail:
13455 {
13456 if (temp1)
13457 delete arg1;
13458 }
13459 {
13460 if (temp2)
13461 delete arg2;
13462 }
13463 return NULL;
13464 }
13465
13466
13467 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13468 PyObject *resultobj = 0;
13469 wxInputStream *arg1 = 0 ;
13470 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13471 int arg3 = (int) -1 ;
13472 wxImage *result = 0 ;
13473 wxPyInputStream *temp1 ;
13474 bool created1 ;
13475 long val2 ;
13476 int ecode2 = 0 ;
13477 int val3 ;
13478 int ecode3 = 0 ;
13479 PyObject * obj0 = 0 ;
13480 PyObject * obj1 = 0 ;
13481 PyObject * obj2 = 0 ;
13482 char * kwnames[] = {
13483 (char *) "stream",(char *) "type",(char *) "index", NULL
13484 };
13485
13486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13487 {
13488 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13489 arg1 = temp1->m_wxis;
13490 created1 = false;
13491 } else {
13492 PyErr_Clear(); // clear the failure of the wxPyConvert above
13493 arg1 = wxPyCBInputStream_create(obj0, false);
13494 if (arg1 == NULL) {
13495 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13496 SWIG_fail;
13497 }
13498 created1 = true;
13499 }
13500 }
13501 if (obj1) {
13502 ecode2 = SWIG_AsVal_long(obj1, &val2);
13503 if (!SWIG_IsOK(ecode2)) {
13504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13505 }
13506 arg2 = static_cast< long >(val2);
13507 }
13508 if (obj2) {
13509 ecode3 = SWIG_AsVal_int(obj2, &val3);
13510 if (!SWIG_IsOK(ecode3)) {
13511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13512 }
13513 arg3 = static_cast< int >(val3);
13514 }
13515 {
13516 PyThreadState* __tstate = wxPyBeginAllowThreads();
13517 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13518 wxPyEndAllowThreads(__tstate);
13519 if (PyErr_Occurred()) SWIG_fail;
13520 }
13521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13522 {
13523 if (created1) delete arg1;
13524 }
13525 return resultobj;
13526 fail:
13527 {
13528 if (created1) delete arg1;
13529 }
13530 return NULL;
13531 }
13532
13533
13534 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13535 PyObject *resultobj = 0;
13536 wxInputStream *arg1 = 0 ;
13537 wxString *arg2 = 0 ;
13538 int arg3 = (int) -1 ;
13539 wxImage *result = 0 ;
13540 wxPyInputStream *temp1 ;
13541 bool created1 ;
13542 bool temp2 = false ;
13543 int val3 ;
13544 int ecode3 = 0 ;
13545 PyObject * obj0 = 0 ;
13546 PyObject * obj1 = 0 ;
13547 PyObject * obj2 = 0 ;
13548 char * kwnames[] = {
13549 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13550 };
13551
13552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13553 {
13554 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13555 arg1 = temp1->m_wxis;
13556 created1 = false;
13557 } else {
13558 PyErr_Clear(); // clear the failure of the wxPyConvert above
13559 arg1 = wxPyCBInputStream_create(obj0, false);
13560 if (arg1 == NULL) {
13561 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13562 SWIG_fail;
13563 }
13564 created1 = true;
13565 }
13566 }
13567 {
13568 arg2 = wxString_in_helper(obj1);
13569 if (arg2 == NULL) SWIG_fail;
13570 temp2 = true;
13571 }
13572 if (obj2) {
13573 ecode3 = SWIG_AsVal_int(obj2, &val3);
13574 if (!SWIG_IsOK(ecode3)) {
13575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13576 }
13577 arg3 = static_cast< int >(val3);
13578 }
13579 {
13580 PyThreadState* __tstate = wxPyBeginAllowThreads();
13581 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13582 wxPyEndAllowThreads(__tstate);
13583 if (PyErr_Occurred()) SWIG_fail;
13584 }
13585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13586 {
13587 if (created1) delete arg1;
13588 }
13589 {
13590 if (temp2)
13591 delete arg2;
13592 }
13593 return resultobj;
13594 fail:
13595 {
13596 if (created1) delete arg1;
13597 }
13598 {
13599 if (temp2)
13600 delete arg2;
13601 }
13602 return NULL;
13603 }
13604
13605
13606 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13607 PyObject *resultobj = 0;
13608 int arg1 = (int) 0 ;
13609 int arg2 = (int) 0 ;
13610 bool arg3 = (bool) true ;
13611 wxImage *result = 0 ;
13612 int val1 ;
13613 int ecode1 = 0 ;
13614 int val2 ;
13615 int ecode2 = 0 ;
13616 bool val3 ;
13617 int ecode3 = 0 ;
13618 PyObject * obj0 = 0 ;
13619 PyObject * obj1 = 0 ;
13620 PyObject * obj2 = 0 ;
13621 char * kwnames[] = {
13622 (char *) "width",(char *) "height",(char *) "clear", NULL
13623 };
13624
13625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13626 if (obj0) {
13627 ecode1 = SWIG_AsVal_int(obj0, &val1);
13628 if (!SWIG_IsOK(ecode1)) {
13629 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13630 }
13631 arg1 = static_cast< int >(val1);
13632 }
13633 if (obj1) {
13634 ecode2 = SWIG_AsVal_int(obj1, &val2);
13635 if (!SWIG_IsOK(ecode2)) {
13636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13637 }
13638 arg2 = static_cast< int >(val2);
13639 }
13640 if (obj2) {
13641 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13642 if (!SWIG_IsOK(ecode3)) {
13643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13644 }
13645 arg3 = static_cast< bool >(val3);
13646 }
13647 {
13648 PyThreadState* __tstate = wxPyBeginAllowThreads();
13649 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13650 wxPyEndAllowThreads(__tstate);
13651 if (PyErr_Occurred()) SWIG_fail;
13652 }
13653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13654 return resultobj;
13655 fail:
13656 return NULL;
13657 }
13658
13659
13660 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13661 PyObject *resultobj = 0;
13662 wxBitmap *arg1 = 0 ;
13663 wxImage *result = 0 ;
13664 void *argp1 = 0 ;
13665 int res1 = 0 ;
13666 PyObject * obj0 = 0 ;
13667 char * kwnames[] = {
13668 (char *) "bitmap", NULL
13669 };
13670
13671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13672 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13673 if (!SWIG_IsOK(res1)) {
13674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13675 }
13676 if (!argp1) {
13677 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13678 }
13679 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13680 {
13681 if (!wxPyCheckForApp()) SWIG_fail;
13682 PyThreadState* __tstate = wxPyBeginAllowThreads();
13683 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13684 wxPyEndAllowThreads(__tstate);
13685 if (PyErr_Occurred()) SWIG_fail;
13686 }
13687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13688 return resultobj;
13689 fail:
13690 return NULL;
13691 }
13692
13693
13694 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13695 PyObject *resultobj = 0;
13696 int arg1 ;
13697 int arg2 ;
13698 buffer arg3 ;
13699 int arg4 ;
13700 wxImage *result = 0 ;
13701 int val1 ;
13702 int ecode1 = 0 ;
13703 int val2 ;
13704 int ecode2 = 0 ;
13705 Py_ssize_t temp3 ;
13706 PyObject * obj0 = 0 ;
13707 PyObject * obj1 = 0 ;
13708 PyObject * obj2 = 0 ;
13709 char * kwnames[] = {
13710 (char *) "width",(char *) "height",(char *) "data", NULL
13711 };
13712
13713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13714 ecode1 = SWIG_AsVal_int(obj0, &val1);
13715 if (!SWIG_IsOK(ecode1)) {
13716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13717 }
13718 arg1 = static_cast< int >(val1);
13719 ecode2 = SWIG_AsVal_int(obj1, &val2);
13720 if (!SWIG_IsOK(ecode2)) {
13721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13722 }
13723 arg2 = static_cast< int >(val2);
13724 {
13725 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13726 arg4 = (int)temp3;
13727 }
13728 {
13729 PyThreadState* __tstate = wxPyBeginAllowThreads();
13730 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13731 wxPyEndAllowThreads(__tstate);
13732 if (PyErr_Occurred()) SWIG_fail;
13733 }
13734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13735 return resultobj;
13736 fail:
13737 return NULL;
13738 }
13739
13740
13741 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj = 0;
13743 int arg1 ;
13744 int arg2 ;
13745 buffer arg3 ;
13746 int arg4 ;
13747 buffer arg5 ;
13748 int arg6 ;
13749 wxImage *result = 0 ;
13750 int val1 ;
13751 int ecode1 = 0 ;
13752 int val2 ;
13753 int ecode2 = 0 ;
13754 Py_ssize_t temp3 ;
13755 Py_ssize_t temp5 ;
13756 PyObject * obj0 = 0 ;
13757 PyObject * obj1 = 0 ;
13758 PyObject * obj2 = 0 ;
13759 PyObject * obj3 = 0 ;
13760 char * kwnames[] = {
13761 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13762 };
13763
13764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13765 ecode1 = SWIG_AsVal_int(obj0, &val1);
13766 if (!SWIG_IsOK(ecode1)) {
13767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13768 }
13769 arg1 = static_cast< int >(val1);
13770 ecode2 = SWIG_AsVal_int(obj1, &val2);
13771 if (!SWIG_IsOK(ecode2)) {
13772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13773 }
13774 arg2 = static_cast< int >(val2);
13775 {
13776 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13777 arg4 = (int)temp3;
13778 }
13779 {
13780 if (obj3 != Py_None) {
13781 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13782 arg6 = (int)temp5;
13783 }
13784 }
13785 {
13786 PyThreadState* __tstate = wxPyBeginAllowThreads();
13787 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13788 wxPyEndAllowThreads(__tstate);
13789 if (PyErr_Occurred()) SWIG_fail;
13790 }
13791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13792 return resultobj;
13793 fail:
13794 return NULL;
13795 }
13796
13797
13798 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13799 PyObject *resultobj = 0;
13800 wxImage *arg1 = (wxImage *) 0 ;
13801 int arg2 ;
13802 int arg3 ;
13803 bool arg4 = (bool) true ;
13804 void *argp1 = 0 ;
13805 int res1 = 0 ;
13806 int val2 ;
13807 int ecode2 = 0 ;
13808 int val3 ;
13809 int ecode3 = 0 ;
13810 bool val4 ;
13811 int ecode4 = 0 ;
13812 PyObject * obj0 = 0 ;
13813 PyObject * obj1 = 0 ;
13814 PyObject * obj2 = 0 ;
13815 PyObject * obj3 = 0 ;
13816 char * kwnames[] = {
13817 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13818 };
13819
13820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13822 if (!SWIG_IsOK(res1)) {
13823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13824 }
13825 arg1 = reinterpret_cast< wxImage * >(argp1);
13826 ecode2 = SWIG_AsVal_int(obj1, &val2);
13827 if (!SWIG_IsOK(ecode2)) {
13828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13829 }
13830 arg2 = static_cast< int >(val2);
13831 ecode3 = SWIG_AsVal_int(obj2, &val3);
13832 if (!SWIG_IsOK(ecode3)) {
13833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13834 }
13835 arg3 = static_cast< int >(val3);
13836 if (obj3) {
13837 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13838 if (!SWIG_IsOK(ecode4)) {
13839 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13840 }
13841 arg4 = static_cast< bool >(val4);
13842 }
13843 {
13844 PyThreadState* __tstate = wxPyBeginAllowThreads();
13845 (arg1)->Create(arg2,arg3,arg4);
13846 wxPyEndAllowThreads(__tstate);
13847 if (PyErr_Occurred()) SWIG_fail;
13848 }
13849 resultobj = SWIG_Py_Void();
13850 return resultobj;
13851 fail:
13852 return NULL;
13853 }
13854
13855
13856 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13857 PyObject *resultobj = 0;
13858 wxImage *arg1 = (wxImage *) 0 ;
13859 void *argp1 = 0 ;
13860 int res1 = 0 ;
13861 PyObject *swig_obj[1] ;
13862
13863 if (!args) SWIG_fail;
13864 swig_obj[0] = args;
13865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13866 if (!SWIG_IsOK(res1)) {
13867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13868 }
13869 arg1 = reinterpret_cast< wxImage * >(argp1);
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 (arg1)->Destroy();
13873 wxPyEndAllowThreads(__tstate);
13874 if (PyErr_Occurred()) SWIG_fail;
13875 }
13876 resultobj = SWIG_Py_Void();
13877 return resultobj;
13878 fail:
13879 return NULL;
13880 }
13881
13882
13883 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13884 PyObject *resultobj = 0;
13885 wxImage *arg1 = (wxImage *) 0 ;
13886 int arg2 ;
13887 int arg3 ;
13888 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13889 SwigValueWrapper<wxImage > result;
13890 void *argp1 = 0 ;
13891 int res1 = 0 ;
13892 int val2 ;
13893 int ecode2 = 0 ;
13894 int val3 ;
13895 int ecode3 = 0 ;
13896 int val4 ;
13897 int ecode4 = 0 ;
13898 PyObject * obj0 = 0 ;
13899 PyObject * obj1 = 0 ;
13900 PyObject * obj2 = 0 ;
13901 PyObject * obj3 = 0 ;
13902 char * kwnames[] = {
13903 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13904 };
13905
13906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13908 if (!SWIG_IsOK(res1)) {
13909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13910 }
13911 arg1 = reinterpret_cast< wxImage * >(argp1);
13912 ecode2 = SWIG_AsVal_int(obj1, &val2);
13913 if (!SWIG_IsOK(ecode2)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13915 }
13916 arg2 = static_cast< int >(val2);
13917 ecode3 = SWIG_AsVal_int(obj2, &val3);
13918 if (!SWIG_IsOK(ecode3)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13920 }
13921 arg3 = static_cast< int >(val3);
13922 if (obj3) {
13923 ecode4 = SWIG_AsVal_int(obj3, &val4);
13924 if (!SWIG_IsOK(ecode4)) {
13925 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13926 }
13927 arg4 = static_cast< int >(val4);
13928 }
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 result = (arg1)->Scale(arg2,arg3,arg4);
13932 wxPyEndAllowThreads(__tstate);
13933 if (PyErr_Occurred()) SWIG_fail;
13934 }
13935 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13936 return resultobj;
13937 fail:
13938 return NULL;
13939 }
13940
13941
13942 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13943 PyObject *resultobj = 0;
13944 wxImage *arg1 = (wxImage *) 0 ;
13945 int arg2 ;
13946 int arg3 ;
13947 SwigValueWrapper<wxImage > result;
13948 void *argp1 = 0 ;
13949 int res1 = 0 ;
13950 int val2 ;
13951 int ecode2 = 0 ;
13952 int val3 ;
13953 int ecode3 = 0 ;
13954 PyObject * obj0 = 0 ;
13955 PyObject * obj1 = 0 ;
13956 PyObject * obj2 = 0 ;
13957 char * kwnames[] = {
13958 (char *) "self",(char *) "width",(char *) "height", NULL
13959 };
13960
13961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13963 if (!SWIG_IsOK(res1)) {
13964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13965 }
13966 arg1 = reinterpret_cast< wxImage * >(argp1);
13967 ecode2 = SWIG_AsVal_int(obj1, &val2);
13968 if (!SWIG_IsOK(ecode2)) {
13969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13970 }
13971 arg2 = static_cast< int >(val2);
13972 ecode3 = SWIG_AsVal_int(obj2, &val3);
13973 if (!SWIG_IsOK(ecode3)) {
13974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13975 }
13976 arg3 = static_cast< int >(val3);
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13980 wxPyEndAllowThreads(__tstate);
13981 if (PyErr_Occurred()) SWIG_fail;
13982 }
13983 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13984 return resultobj;
13985 fail:
13986 return NULL;
13987 }
13988
13989
13990 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13991 PyObject *resultobj = 0;
13992 wxImage *arg1 = (wxImage *) 0 ;
13993 int arg2 ;
13994 int arg3 ;
13995 SwigValueWrapper<wxImage > result;
13996 void *argp1 = 0 ;
13997 int res1 = 0 ;
13998 int val2 ;
13999 int ecode2 = 0 ;
14000 int val3 ;
14001 int ecode3 = 0 ;
14002 PyObject * obj0 = 0 ;
14003 PyObject * obj1 = 0 ;
14004 PyObject * obj2 = 0 ;
14005 char * kwnames[] = {
14006 (char *) "self",(char *) "width",(char *) "height", NULL
14007 };
14008
14009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14011 if (!SWIG_IsOK(res1)) {
14012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14013 }
14014 arg1 = reinterpret_cast< wxImage * >(argp1);
14015 ecode2 = SWIG_AsVal_int(obj1, &val2);
14016 if (!SWIG_IsOK(ecode2)) {
14017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14018 }
14019 arg2 = static_cast< int >(val2);
14020 ecode3 = SWIG_AsVal_int(obj2, &val3);
14021 if (!SWIG_IsOK(ecode3)) {
14022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14023 }
14024 arg3 = static_cast< int >(val3);
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14028 wxPyEndAllowThreads(__tstate);
14029 if (PyErr_Occurred()) SWIG_fail;
14030 }
14031 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14032 return resultobj;
14033 fail:
14034 return NULL;
14035 }
14036
14037
14038 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14039 PyObject *resultobj = 0;
14040 wxImage *arg1 = (wxImage *) 0 ;
14041 int arg2 ;
14042 SwigValueWrapper<wxImage > result;
14043 void *argp1 = 0 ;
14044 int res1 = 0 ;
14045 int val2 ;
14046 int ecode2 = 0 ;
14047 PyObject * obj0 = 0 ;
14048 PyObject * obj1 = 0 ;
14049 char * kwnames[] = {
14050 (char *) "self",(char *) "radius", NULL
14051 };
14052
14053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14055 if (!SWIG_IsOK(res1)) {
14056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14057 }
14058 arg1 = reinterpret_cast< wxImage * >(argp1);
14059 ecode2 = SWIG_AsVal_int(obj1, &val2);
14060 if (!SWIG_IsOK(ecode2)) {
14061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14062 }
14063 arg2 = static_cast< int >(val2);
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 result = (arg1)->Blur(arg2);
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14071 return resultobj;
14072 fail:
14073 return NULL;
14074 }
14075
14076
14077 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14078 PyObject *resultobj = 0;
14079 wxImage *arg1 = (wxImage *) 0 ;
14080 int arg2 ;
14081 SwigValueWrapper<wxImage > result;
14082 void *argp1 = 0 ;
14083 int res1 = 0 ;
14084 int val2 ;
14085 int ecode2 = 0 ;
14086 PyObject * obj0 = 0 ;
14087 PyObject * obj1 = 0 ;
14088 char * kwnames[] = {
14089 (char *) "self",(char *) "radius", NULL
14090 };
14091
14092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14094 if (!SWIG_IsOK(res1)) {
14095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14096 }
14097 arg1 = reinterpret_cast< wxImage * >(argp1);
14098 ecode2 = SWIG_AsVal_int(obj1, &val2);
14099 if (!SWIG_IsOK(ecode2)) {
14100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14101 }
14102 arg2 = static_cast< int >(val2);
14103 {
14104 PyThreadState* __tstate = wxPyBeginAllowThreads();
14105 result = (arg1)->BlurHorizontal(arg2);
14106 wxPyEndAllowThreads(__tstate);
14107 if (PyErr_Occurred()) SWIG_fail;
14108 }
14109 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14110 return resultobj;
14111 fail:
14112 return NULL;
14113 }
14114
14115
14116 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14117 PyObject *resultobj = 0;
14118 wxImage *arg1 = (wxImage *) 0 ;
14119 int arg2 ;
14120 SwigValueWrapper<wxImage > result;
14121 void *argp1 = 0 ;
14122 int res1 = 0 ;
14123 int val2 ;
14124 int ecode2 = 0 ;
14125 PyObject * obj0 = 0 ;
14126 PyObject * obj1 = 0 ;
14127 char * kwnames[] = {
14128 (char *) "self",(char *) "radius", NULL
14129 };
14130
14131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14133 if (!SWIG_IsOK(res1)) {
14134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14135 }
14136 arg1 = reinterpret_cast< wxImage * >(argp1);
14137 ecode2 = SWIG_AsVal_int(obj1, &val2);
14138 if (!SWIG_IsOK(ecode2)) {
14139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14140 }
14141 arg2 = static_cast< int >(val2);
14142 {
14143 PyThreadState* __tstate = wxPyBeginAllowThreads();
14144 result = (arg1)->BlurVertical(arg2);
14145 wxPyEndAllowThreads(__tstate);
14146 if (PyErr_Occurred()) SWIG_fail;
14147 }
14148 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14149 return resultobj;
14150 fail:
14151 return NULL;
14152 }
14153
14154
14155 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14156 PyObject *resultobj = 0;
14157 wxImage *arg1 = (wxImage *) 0 ;
14158 int arg2 ;
14159 int arg3 ;
14160 SwigValueWrapper<wxImage > result;
14161 void *argp1 = 0 ;
14162 int res1 = 0 ;
14163 int val2 ;
14164 int ecode2 = 0 ;
14165 int val3 ;
14166 int ecode3 = 0 ;
14167 PyObject * obj0 = 0 ;
14168 PyObject * obj1 = 0 ;
14169 PyObject * obj2 = 0 ;
14170 char * kwnames[] = {
14171 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14172 };
14173
14174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14176 if (!SWIG_IsOK(res1)) {
14177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14178 }
14179 arg1 = reinterpret_cast< wxImage * >(argp1);
14180 ecode2 = SWIG_AsVal_int(obj1, &val2);
14181 if (!SWIG_IsOK(ecode2)) {
14182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14183 }
14184 arg2 = static_cast< int >(val2);
14185 ecode3 = SWIG_AsVal_int(obj2, &val3);
14186 if (!SWIG_IsOK(ecode3)) {
14187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14188 }
14189 arg3 = static_cast< int >(val3);
14190 {
14191 PyThreadState* __tstate = wxPyBeginAllowThreads();
14192 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14193 wxPyEndAllowThreads(__tstate);
14194 if (PyErr_Occurred()) SWIG_fail;
14195 }
14196 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14197 return resultobj;
14198 fail:
14199 return NULL;
14200 }
14201
14202
14203 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14204 PyObject *resultobj = 0;
14205 wxImage *arg1 = (wxImage *) 0 ;
14206 int arg2 ;
14207 int arg3 ;
14208 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14209 wxImage *result = 0 ;
14210 void *argp1 = 0 ;
14211 int res1 = 0 ;
14212 int val2 ;
14213 int ecode2 = 0 ;
14214 int val3 ;
14215 int ecode3 = 0 ;
14216 int val4 ;
14217 int ecode4 = 0 ;
14218 PyObject * obj0 = 0 ;
14219 PyObject * obj1 = 0 ;
14220 PyObject * obj2 = 0 ;
14221 PyObject * obj3 = 0 ;
14222 char * kwnames[] = {
14223 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14224 };
14225
14226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14228 if (!SWIG_IsOK(res1)) {
14229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14230 }
14231 arg1 = reinterpret_cast< wxImage * >(argp1);
14232 ecode2 = SWIG_AsVal_int(obj1, &val2);
14233 if (!SWIG_IsOK(ecode2)) {
14234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14235 }
14236 arg2 = static_cast< int >(val2);
14237 ecode3 = SWIG_AsVal_int(obj2, &val3);
14238 if (!SWIG_IsOK(ecode3)) {
14239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14240 }
14241 arg3 = static_cast< int >(val3);
14242 if (obj3) {
14243 ecode4 = SWIG_AsVal_int(obj3, &val4);
14244 if (!SWIG_IsOK(ecode4)) {
14245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14246 }
14247 arg4 = static_cast< int >(val4);
14248 }
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 {
14252 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14253 result = (wxImage *) &_result_ref;
14254 }
14255 wxPyEndAllowThreads(__tstate);
14256 if (PyErr_Occurred()) SWIG_fail;
14257 }
14258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14259 return resultobj;
14260 fail:
14261 return NULL;
14262 }
14263
14264
14265 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14266 PyObject *resultobj = 0;
14267 wxImage *arg1 = (wxImage *) 0 ;
14268 wxSize *arg2 = 0 ;
14269 wxPoint *arg3 = 0 ;
14270 int arg4 = (int) -1 ;
14271 int arg5 = (int) -1 ;
14272 int arg6 = (int) -1 ;
14273 wxImage *result = 0 ;
14274 void *argp1 = 0 ;
14275 int res1 = 0 ;
14276 wxSize temp2 ;
14277 wxPoint temp3 ;
14278 int val4 ;
14279 int ecode4 = 0 ;
14280 int val5 ;
14281 int ecode5 = 0 ;
14282 int val6 ;
14283 int ecode6 = 0 ;
14284 PyObject * obj0 = 0 ;
14285 PyObject * obj1 = 0 ;
14286 PyObject * obj2 = 0 ;
14287 PyObject * obj3 = 0 ;
14288 PyObject * obj4 = 0 ;
14289 PyObject * obj5 = 0 ;
14290 char * kwnames[] = {
14291 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14292 };
14293
14294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14296 if (!SWIG_IsOK(res1)) {
14297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14298 }
14299 arg1 = reinterpret_cast< wxImage * >(argp1);
14300 {
14301 arg2 = &temp2;
14302 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14303 }
14304 {
14305 arg3 = &temp3;
14306 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14307 }
14308 if (obj3) {
14309 ecode4 = SWIG_AsVal_int(obj3, &val4);
14310 if (!SWIG_IsOK(ecode4)) {
14311 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14312 }
14313 arg4 = static_cast< int >(val4);
14314 }
14315 if (obj4) {
14316 ecode5 = SWIG_AsVal_int(obj4, &val5);
14317 if (!SWIG_IsOK(ecode5)) {
14318 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14319 }
14320 arg5 = static_cast< int >(val5);
14321 }
14322 if (obj5) {
14323 ecode6 = SWIG_AsVal_int(obj5, &val6);
14324 if (!SWIG_IsOK(ecode6)) {
14325 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14326 }
14327 arg6 = static_cast< int >(val6);
14328 }
14329 {
14330 PyThreadState* __tstate = wxPyBeginAllowThreads();
14331 {
14332 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14333 result = (wxImage *) &_result_ref;
14334 }
14335 wxPyEndAllowThreads(__tstate);
14336 if (PyErr_Occurred()) SWIG_fail;
14337 }
14338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14339 return resultobj;
14340 fail:
14341 return NULL;
14342 }
14343
14344
14345 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14346 PyObject *resultobj = 0;
14347 wxImage *arg1 = (wxImage *) 0 ;
14348 int arg2 ;
14349 int arg3 ;
14350 byte arg4 ;
14351 byte arg5 ;
14352 byte arg6 ;
14353 void *argp1 = 0 ;
14354 int res1 = 0 ;
14355 int val2 ;
14356 int ecode2 = 0 ;
14357 int val3 ;
14358 int ecode3 = 0 ;
14359 unsigned char val4 ;
14360 int ecode4 = 0 ;
14361 unsigned char val5 ;
14362 int ecode5 = 0 ;
14363 unsigned char val6 ;
14364 int ecode6 = 0 ;
14365 PyObject * obj0 = 0 ;
14366 PyObject * obj1 = 0 ;
14367 PyObject * obj2 = 0 ;
14368 PyObject * obj3 = 0 ;
14369 PyObject * obj4 = 0 ;
14370 PyObject * obj5 = 0 ;
14371 char * kwnames[] = {
14372 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14373 };
14374
14375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14377 if (!SWIG_IsOK(res1)) {
14378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14379 }
14380 arg1 = reinterpret_cast< wxImage * >(argp1);
14381 ecode2 = SWIG_AsVal_int(obj1, &val2);
14382 if (!SWIG_IsOK(ecode2)) {
14383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14384 }
14385 arg2 = static_cast< int >(val2);
14386 ecode3 = SWIG_AsVal_int(obj2, &val3);
14387 if (!SWIG_IsOK(ecode3)) {
14388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14389 }
14390 arg3 = static_cast< int >(val3);
14391 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14392 if (!SWIG_IsOK(ecode4)) {
14393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14394 }
14395 arg4 = static_cast< byte >(val4);
14396 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14397 if (!SWIG_IsOK(ecode5)) {
14398 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14399 }
14400 arg5 = static_cast< byte >(val5);
14401 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14402 if (!SWIG_IsOK(ecode6)) {
14403 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14404 }
14405 arg6 = static_cast< byte >(val6);
14406 {
14407 PyThreadState* __tstate = wxPyBeginAllowThreads();
14408 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14409 wxPyEndAllowThreads(__tstate);
14410 if (PyErr_Occurred()) SWIG_fail;
14411 }
14412 resultobj = SWIG_Py_Void();
14413 return resultobj;
14414 fail:
14415 return NULL;
14416 }
14417
14418
14419 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14420 PyObject *resultobj = 0;
14421 wxImage *arg1 = (wxImage *) 0 ;
14422 wxRect *arg2 = 0 ;
14423 byte arg3 ;
14424 byte arg4 ;
14425 byte arg5 ;
14426 void *argp1 = 0 ;
14427 int res1 = 0 ;
14428 wxRect temp2 ;
14429 unsigned char val3 ;
14430 int ecode3 = 0 ;
14431 unsigned char val4 ;
14432 int ecode4 = 0 ;
14433 unsigned char val5 ;
14434 int ecode5 = 0 ;
14435 PyObject * obj0 = 0 ;
14436 PyObject * obj1 = 0 ;
14437 PyObject * obj2 = 0 ;
14438 PyObject * obj3 = 0 ;
14439 PyObject * obj4 = 0 ;
14440 char * kwnames[] = {
14441 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14442 };
14443
14444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14446 if (!SWIG_IsOK(res1)) {
14447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14448 }
14449 arg1 = reinterpret_cast< wxImage * >(argp1);
14450 {
14451 arg2 = &temp2;
14452 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14453 }
14454 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14455 if (!SWIG_IsOK(ecode3)) {
14456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14457 }
14458 arg3 = static_cast< byte >(val3);
14459 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14460 if (!SWIG_IsOK(ecode4)) {
14461 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14462 }
14463 arg4 = static_cast< byte >(val4);
14464 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14465 if (!SWIG_IsOK(ecode5)) {
14466 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14467 }
14468 arg5 = static_cast< byte >(val5);
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14472 wxPyEndAllowThreads(__tstate);
14473 if (PyErr_Occurred()) SWIG_fail;
14474 }
14475 resultobj = SWIG_Py_Void();
14476 return resultobj;
14477 fail:
14478 return NULL;
14479 }
14480
14481
14482 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14483 PyObject *resultobj = 0;
14484 wxImage *arg1 = (wxImage *) 0 ;
14485 int arg2 ;
14486 int arg3 ;
14487 byte result;
14488 void *argp1 = 0 ;
14489 int res1 = 0 ;
14490 int val2 ;
14491 int ecode2 = 0 ;
14492 int val3 ;
14493 int ecode3 = 0 ;
14494 PyObject * obj0 = 0 ;
14495 PyObject * obj1 = 0 ;
14496 PyObject * obj2 = 0 ;
14497 char * kwnames[] = {
14498 (char *) "self",(char *) "x",(char *) "y", NULL
14499 };
14500
14501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14503 if (!SWIG_IsOK(res1)) {
14504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14505 }
14506 arg1 = reinterpret_cast< wxImage * >(argp1);
14507 ecode2 = SWIG_AsVal_int(obj1, &val2);
14508 if (!SWIG_IsOK(ecode2)) {
14509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14510 }
14511 arg2 = static_cast< int >(val2);
14512 ecode3 = SWIG_AsVal_int(obj2, &val3);
14513 if (!SWIG_IsOK(ecode3)) {
14514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14515 }
14516 arg3 = static_cast< int >(val3);
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 result = (byte)(arg1)->GetRed(arg2,arg3);
14520 wxPyEndAllowThreads(__tstate);
14521 if (PyErr_Occurred()) SWIG_fail;
14522 }
14523 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14524 return resultobj;
14525 fail:
14526 return NULL;
14527 }
14528
14529
14530 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14531 PyObject *resultobj = 0;
14532 wxImage *arg1 = (wxImage *) 0 ;
14533 int arg2 ;
14534 int arg3 ;
14535 byte result;
14536 void *argp1 = 0 ;
14537 int res1 = 0 ;
14538 int val2 ;
14539 int ecode2 = 0 ;
14540 int val3 ;
14541 int ecode3 = 0 ;
14542 PyObject * obj0 = 0 ;
14543 PyObject * obj1 = 0 ;
14544 PyObject * obj2 = 0 ;
14545 char * kwnames[] = {
14546 (char *) "self",(char *) "x",(char *) "y", NULL
14547 };
14548
14549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14551 if (!SWIG_IsOK(res1)) {
14552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14553 }
14554 arg1 = reinterpret_cast< wxImage * >(argp1);
14555 ecode2 = SWIG_AsVal_int(obj1, &val2);
14556 if (!SWIG_IsOK(ecode2)) {
14557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14558 }
14559 arg2 = static_cast< int >(val2);
14560 ecode3 = SWIG_AsVal_int(obj2, &val3);
14561 if (!SWIG_IsOK(ecode3)) {
14562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14563 }
14564 arg3 = static_cast< int >(val3);
14565 {
14566 PyThreadState* __tstate = wxPyBeginAllowThreads();
14567 result = (byte)(arg1)->GetGreen(arg2,arg3);
14568 wxPyEndAllowThreads(__tstate);
14569 if (PyErr_Occurred()) SWIG_fail;
14570 }
14571 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14572 return resultobj;
14573 fail:
14574 return NULL;
14575 }
14576
14577
14578 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14579 PyObject *resultobj = 0;
14580 wxImage *arg1 = (wxImage *) 0 ;
14581 int arg2 ;
14582 int arg3 ;
14583 byte result;
14584 void *argp1 = 0 ;
14585 int res1 = 0 ;
14586 int val2 ;
14587 int ecode2 = 0 ;
14588 int val3 ;
14589 int ecode3 = 0 ;
14590 PyObject * obj0 = 0 ;
14591 PyObject * obj1 = 0 ;
14592 PyObject * obj2 = 0 ;
14593 char * kwnames[] = {
14594 (char *) "self",(char *) "x",(char *) "y", NULL
14595 };
14596
14597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14599 if (!SWIG_IsOK(res1)) {
14600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14601 }
14602 arg1 = reinterpret_cast< wxImage * >(argp1);
14603 ecode2 = SWIG_AsVal_int(obj1, &val2);
14604 if (!SWIG_IsOK(ecode2)) {
14605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14606 }
14607 arg2 = static_cast< int >(val2);
14608 ecode3 = SWIG_AsVal_int(obj2, &val3);
14609 if (!SWIG_IsOK(ecode3)) {
14610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14611 }
14612 arg3 = static_cast< int >(val3);
14613 {
14614 PyThreadState* __tstate = wxPyBeginAllowThreads();
14615 result = (byte)(arg1)->GetBlue(arg2,arg3);
14616 wxPyEndAllowThreads(__tstate);
14617 if (PyErr_Occurred()) SWIG_fail;
14618 }
14619 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14620 return resultobj;
14621 fail:
14622 return NULL;
14623 }
14624
14625
14626 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14627 PyObject *resultobj = 0;
14628 wxImage *arg1 = (wxImage *) 0 ;
14629 int arg2 ;
14630 int arg3 ;
14631 byte arg4 ;
14632 void *argp1 = 0 ;
14633 int res1 = 0 ;
14634 int val2 ;
14635 int ecode2 = 0 ;
14636 int val3 ;
14637 int ecode3 = 0 ;
14638 unsigned char val4 ;
14639 int ecode4 = 0 ;
14640 PyObject * obj0 = 0 ;
14641 PyObject * obj1 = 0 ;
14642 PyObject * obj2 = 0 ;
14643 PyObject * obj3 = 0 ;
14644 char * kwnames[] = {
14645 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14646 };
14647
14648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14650 if (!SWIG_IsOK(res1)) {
14651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14652 }
14653 arg1 = reinterpret_cast< wxImage * >(argp1);
14654 ecode2 = SWIG_AsVal_int(obj1, &val2);
14655 if (!SWIG_IsOK(ecode2)) {
14656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14657 }
14658 arg2 = static_cast< int >(val2);
14659 ecode3 = SWIG_AsVal_int(obj2, &val3);
14660 if (!SWIG_IsOK(ecode3)) {
14661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14662 }
14663 arg3 = static_cast< int >(val3);
14664 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14665 if (!SWIG_IsOK(ecode4)) {
14666 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14667 }
14668 arg4 = static_cast< byte >(val4);
14669 {
14670 PyThreadState* __tstate = wxPyBeginAllowThreads();
14671 (arg1)->SetAlpha(arg2,arg3,arg4);
14672 wxPyEndAllowThreads(__tstate);
14673 if (PyErr_Occurred()) SWIG_fail;
14674 }
14675 resultobj = SWIG_Py_Void();
14676 return resultobj;
14677 fail:
14678 return NULL;
14679 }
14680
14681
14682 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14683 PyObject *resultobj = 0;
14684 wxImage *arg1 = (wxImage *) 0 ;
14685 int arg2 ;
14686 int arg3 ;
14687 byte result;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 int val2 ;
14691 int ecode2 = 0 ;
14692 int val3 ;
14693 int ecode3 = 0 ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 PyObject * obj2 = 0 ;
14697 char * kwnames[] = {
14698 (char *) "self",(char *) "x",(char *) "y", NULL
14699 };
14700
14701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14703 if (!SWIG_IsOK(res1)) {
14704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14705 }
14706 arg1 = reinterpret_cast< wxImage * >(argp1);
14707 ecode2 = SWIG_AsVal_int(obj1, &val2);
14708 if (!SWIG_IsOK(ecode2)) {
14709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14710 }
14711 arg2 = static_cast< int >(val2);
14712 ecode3 = SWIG_AsVal_int(obj2, &val3);
14713 if (!SWIG_IsOK(ecode3)) {
14714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14715 }
14716 arg3 = static_cast< int >(val3);
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14720 wxPyEndAllowThreads(__tstate);
14721 if (PyErr_Occurred()) SWIG_fail;
14722 }
14723 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14724 return resultobj;
14725 fail:
14726 return NULL;
14727 }
14728
14729
14730 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14731 PyObject *resultobj = 0;
14732 wxImage *arg1 = (wxImage *) 0 ;
14733 bool result;
14734 void *argp1 = 0 ;
14735 int res1 = 0 ;
14736 PyObject *swig_obj[1] ;
14737
14738 if (!args) SWIG_fail;
14739 swig_obj[0] = args;
14740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14741 if (!SWIG_IsOK(res1)) {
14742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14743 }
14744 arg1 = reinterpret_cast< wxImage * >(argp1);
14745 {
14746 PyThreadState* __tstate = wxPyBeginAllowThreads();
14747 result = (bool)(arg1)->HasAlpha();
14748 wxPyEndAllowThreads(__tstate);
14749 if (PyErr_Occurred()) SWIG_fail;
14750 }
14751 {
14752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14753 }
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14761 PyObject *resultobj = 0;
14762 wxImage *arg1 = (wxImage *) 0 ;
14763 void *argp1 = 0 ;
14764 int res1 = 0 ;
14765 PyObject *swig_obj[1] ;
14766
14767 if (!args) SWIG_fail;
14768 swig_obj[0] = args;
14769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14770 if (!SWIG_IsOK(res1)) {
14771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14772 }
14773 arg1 = reinterpret_cast< wxImage * >(argp1);
14774 {
14775 PyThreadState* __tstate = wxPyBeginAllowThreads();
14776 (arg1)->InitAlpha();
14777 wxPyEndAllowThreads(__tstate);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 }
14780 resultobj = SWIG_Py_Void();
14781 return resultobj;
14782 fail:
14783 return NULL;
14784 }
14785
14786
14787 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14788 PyObject *resultobj = 0;
14789 wxImage *arg1 = (wxImage *) 0 ;
14790 int arg2 ;
14791 int arg3 ;
14792 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14793 bool result;
14794 void *argp1 = 0 ;
14795 int res1 = 0 ;
14796 int val2 ;
14797 int ecode2 = 0 ;
14798 int val3 ;
14799 int ecode3 = 0 ;
14800 unsigned char val4 ;
14801 int ecode4 = 0 ;
14802 PyObject * obj0 = 0 ;
14803 PyObject * obj1 = 0 ;
14804 PyObject * obj2 = 0 ;
14805 PyObject * obj3 = 0 ;
14806 char * kwnames[] = {
14807 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14808 };
14809
14810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14812 if (!SWIG_IsOK(res1)) {
14813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14814 }
14815 arg1 = reinterpret_cast< wxImage * >(argp1);
14816 ecode2 = SWIG_AsVal_int(obj1, &val2);
14817 if (!SWIG_IsOK(ecode2)) {
14818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14819 }
14820 arg2 = static_cast< int >(val2);
14821 ecode3 = SWIG_AsVal_int(obj2, &val3);
14822 if (!SWIG_IsOK(ecode3)) {
14823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14824 }
14825 arg3 = static_cast< int >(val3);
14826 if (obj3) {
14827 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14828 if (!SWIG_IsOK(ecode4)) {
14829 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14830 }
14831 arg4 = static_cast< byte >(val4);
14832 }
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14836 wxPyEndAllowThreads(__tstate);
14837 if (PyErr_Occurred()) SWIG_fail;
14838 }
14839 {
14840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14841 }
14842 return resultobj;
14843 fail:
14844 return NULL;
14845 }
14846
14847
14848 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14849 PyObject *resultobj = 0;
14850 wxImage *arg1 = (wxImage *) 0 ;
14851 byte *arg2 = (byte *) 0 ;
14852 byte *arg3 = (byte *) 0 ;
14853 byte *arg4 = (byte *) 0 ;
14854 byte arg5 = (byte) 0 ;
14855 byte arg6 = (byte) 0 ;
14856 byte arg7 = (byte) 0 ;
14857 bool result;
14858 void *argp1 = 0 ;
14859 int res1 = 0 ;
14860 byte temp2 ;
14861 int res2 = SWIG_TMPOBJ ;
14862 byte temp3 ;
14863 int res3 = SWIG_TMPOBJ ;
14864 byte temp4 ;
14865 int res4 = SWIG_TMPOBJ ;
14866 unsigned char val5 ;
14867 int ecode5 = 0 ;
14868 unsigned char val6 ;
14869 int ecode6 = 0 ;
14870 unsigned char val7 ;
14871 int ecode7 = 0 ;
14872 PyObject * obj0 = 0 ;
14873 PyObject * obj1 = 0 ;
14874 PyObject * obj2 = 0 ;
14875 PyObject * obj3 = 0 ;
14876 char * kwnames[] = {
14877 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14878 };
14879
14880 arg2 = &temp2;
14881 arg3 = &temp3;
14882 arg4 = &temp4;
14883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14885 if (!SWIG_IsOK(res1)) {
14886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14887 }
14888 arg1 = reinterpret_cast< wxImage * >(argp1);
14889 if (obj1) {
14890 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14891 if (!SWIG_IsOK(ecode5)) {
14892 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14893 }
14894 arg5 = static_cast< byte >(val5);
14895 }
14896 if (obj2) {
14897 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14898 if (!SWIG_IsOK(ecode6)) {
14899 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14900 }
14901 arg6 = static_cast< byte >(val6);
14902 }
14903 if (obj3) {
14904 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14905 if (!SWIG_IsOK(ecode7)) {
14906 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14907 }
14908 arg7 = static_cast< byte >(val7);
14909 }
14910 {
14911 PyThreadState* __tstate = wxPyBeginAllowThreads();
14912 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14913 wxPyEndAllowThreads(__tstate);
14914 if (PyErr_Occurred()) SWIG_fail;
14915 }
14916 {
14917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14918 }
14919 if (SWIG_IsTmpObj(res2)) {
14920 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14921 } else {
14922 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14924 }
14925 if (SWIG_IsTmpObj(res3)) {
14926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14927 } else {
14928 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14930 }
14931 if (SWIG_IsTmpObj(res4)) {
14932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14933 } else {
14934 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14936 }
14937 return resultobj;
14938 fail:
14939 return NULL;
14940 }
14941
14942
14943 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14944 PyObject *resultobj = 0;
14945 wxImage *arg1 = (wxImage *) 0 ;
14946 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14947 bool result;
14948 void *argp1 = 0 ;
14949 int res1 = 0 ;
14950 unsigned char val2 ;
14951 int ecode2 = 0 ;
14952 PyObject * obj0 = 0 ;
14953 PyObject * obj1 = 0 ;
14954 char * kwnames[] = {
14955 (char *) "self",(char *) "threshold", NULL
14956 };
14957
14958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14960 if (!SWIG_IsOK(res1)) {
14961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14962 }
14963 arg1 = reinterpret_cast< wxImage * >(argp1);
14964 if (obj1) {
14965 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14966 if (!SWIG_IsOK(ecode2)) {
14967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14968 }
14969 arg2 = static_cast< byte >(val2);
14970 }
14971 {
14972 PyThreadState* __tstate = wxPyBeginAllowThreads();
14973 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14974 wxPyEndAllowThreads(__tstate);
14975 if (PyErr_Occurred()) SWIG_fail;
14976 }
14977 {
14978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14979 }
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14987 PyObject *resultobj = 0;
14988 wxImage *arg1 = (wxImage *) 0 ;
14989 byte arg2 ;
14990 byte arg3 ;
14991 byte arg4 ;
14992 bool result;
14993 void *argp1 = 0 ;
14994 int res1 = 0 ;
14995 unsigned char val2 ;
14996 int ecode2 = 0 ;
14997 unsigned char val3 ;
14998 int ecode3 = 0 ;
14999 unsigned char val4 ;
15000 int ecode4 = 0 ;
15001 PyObject * obj0 = 0 ;
15002 PyObject * obj1 = 0 ;
15003 PyObject * obj2 = 0 ;
15004 PyObject * obj3 = 0 ;
15005 char * kwnames[] = {
15006 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15007 };
15008
15009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15011 if (!SWIG_IsOK(res1)) {
15012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15013 }
15014 arg1 = reinterpret_cast< wxImage * >(argp1);
15015 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15016 if (!SWIG_IsOK(ecode2)) {
15017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15018 }
15019 arg2 = static_cast< byte >(val2);
15020 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15021 if (!SWIG_IsOK(ecode3)) {
15022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15023 }
15024 arg3 = static_cast< byte >(val3);
15025 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15026 if (!SWIG_IsOK(ecode4)) {
15027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15028 }
15029 arg4 = static_cast< byte >(val4);
15030 {
15031 PyThreadState* __tstate = wxPyBeginAllowThreads();
15032 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15033 wxPyEndAllowThreads(__tstate);
15034 if (PyErr_Occurred()) SWIG_fail;
15035 }
15036 {
15037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15038 }
15039 return resultobj;
15040 fail:
15041 return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15046 PyObject *resultobj = 0;
15047 wxImage *arg1 = (wxImage *) 0 ;
15048 wxImage *arg2 = 0 ;
15049 byte arg3 ;
15050 byte arg4 ;
15051 byte arg5 ;
15052 bool result;
15053 void *argp1 = 0 ;
15054 int res1 = 0 ;
15055 void *argp2 = 0 ;
15056 int res2 = 0 ;
15057 unsigned char val3 ;
15058 int ecode3 = 0 ;
15059 unsigned char val4 ;
15060 int ecode4 = 0 ;
15061 unsigned char val5 ;
15062 int ecode5 = 0 ;
15063 PyObject * obj0 = 0 ;
15064 PyObject * obj1 = 0 ;
15065 PyObject * obj2 = 0 ;
15066 PyObject * obj3 = 0 ;
15067 PyObject * obj4 = 0 ;
15068 char * kwnames[] = {
15069 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15070 };
15071
15072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15074 if (!SWIG_IsOK(res1)) {
15075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15076 }
15077 arg1 = reinterpret_cast< wxImage * >(argp1);
15078 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15079 if (!SWIG_IsOK(res2)) {
15080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15081 }
15082 if (!argp2) {
15083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15084 }
15085 arg2 = reinterpret_cast< wxImage * >(argp2);
15086 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15087 if (!SWIG_IsOK(ecode3)) {
15088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15089 }
15090 arg3 = static_cast< byte >(val3);
15091 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15092 if (!SWIG_IsOK(ecode4)) {
15093 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15094 }
15095 arg4 = static_cast< byte >(val4);
15096 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15097 if (!SWIG_IsOK(ecode5)) {
15098 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15099 }
15100 arg5 = static_cast< byte >(val5);
15101 {
15102 PyThreadState* __tstate = wxPyBeginAllowThreads();
15103 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15104 wxPyEndAllowThreads(__tstate);
15105 if (PyErr_Occurred()) SWIG_fail;
15106 }
15107 {
15108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15109 }
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj = 0;
15118 wxString *arg1 = 0 ;
15119 bool result;
15120 bool temp1 = false ;
15121 PyObject * obj0 = 0 ;
15122 char * kwnames[] = {
15123 (char *) "filename", NULL
15124 };
15125
15126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15127 {
15128 arg1 = wxString_in_helper(obj0);
15129 if (arg1 == NULL) SWIG_fail;
15130 temp1 = true;
15131 }
15132 {
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15135 wxPyEndAllowThreads(__tstate);
15136 if (PyErr_Occurred()) SWIG_fail;
15137 }
15138 {
15139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15140 }
15141 {
15142 if (temp1)
15143 delete arg1;
15144 }
15145 return resultobj;
15146 fail:
15147 {
15148 if (temp1)
15149 delete arg1;
15150 }
15151 return NULL;
15152 }
15153
15154
15155 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15156 PyObject *resultobj = 0;
15157 wxString *arg1 = 0 ;
15158 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15159 int result;
15160 bool temp1 = false ;
15161 long val2 ;
15162 int ecode2 = 0 ;
15163 PyObject * obj0 = 0 ;
15164 PyObject * obj1 = 0 ;
15165 char * kwnames[] = {
15166 (char *) "filename",(char *) "type", NULL
15167 };
15168
15169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15170 {
15171 arg1 = wxString_in_helper(obj0);
15172 if (arg1 == NULL) SWIG_fail;
15173 temp1 = true;
15174 }
15175 if (obj1) {
15176 ecode2 = SWIG_AsVal_long(obj1, &val2);
15177 if (!SWIG_IsOK(ecode2)) {
15178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15179 }
15180 arg2 = static_cast< long >(val2);
15181 }
15182 {
15183 PyThreadState* __tstate = wxPyBeginAllowThreads();
15184 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15185 wxPyEndAllowThreads(__tstate);
15186 if (PyErr_Occurred()) SWIG_fail;
15187 }
15188 resultobj = SWIG_From_int(static_cast< int >(result));
15189 {
15190 if (temp1)
15191 delete arg1;
15192 }
15193 return resultobj;
15194 fail:
15195 {
15196 if (temp1)
15197 delete arg1;
15198 }
15199 return NULL;
15200 }
15201
15202
15203 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15204 PyObject *resultobj = 0;
15205 wxImage *arg1 = (wxImage *) 0 ;
15206 wxString *arg2 = 0 ;
15207 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15208 int arg4 = (int) -1 ;
15209 bool result;
15210 void *argp1 = 0 ;
15211 int res1 = 0 ;
15212 bool temp2 = false ;
15213 long val3 ;
15214 int ecode3 = 0 ;
15215 int val4 ;
15216 int ecode4 = 0 ;
15217 PyObject * obj0 = 0 ;
15218 PyObject * obj1 = 0 ;
15219 PyObject * obj2 = 0 ;
15220 PyObject * obj3 = 0 ;
15221 char * kwnames[] = {
15222 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15223 };
15224
15225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15227 if (!SWIG_IsOK(res1)) {
15228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15229 }
15230 arg1 = reinterpret_cast< wxImage * >(argp1);
15231 {
15232 arg2 = wxString_in_helper(obj1);
15233 if (arg2 == NULL) SWIG_fail;
15234 temp2 = true;
15235 }
15236 if (obj2) {
15237 ecode3 = SWIG_AsVal_long(obj2, &val3);
15238 if (!SWIG_IsOK(ecode3)) {
15239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15240 }
15241 arg3 = static_cast< long >(val3);
15242 }
15243 if (obj3) {
15244 ecode4 = SWIG_AsVal_int(obj3, &val4);
15245 if (!SWIG_IsOK(ecode4)) {
15246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15247 }
15248 arg4 = static_cast< int >(val4);
15249 }
15250 {
15251 PyThreadState* __tstate = wxPyBeginAllowThreads();
15252 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15253 wxPyEndAllowThreads(__tstate);
15254 if (PyErr_Occurred()) SWIG_fail;
15255 }
15256 {
15257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15258 }
15259 {
15260 if (temp2)
15261 delete arg2;
15262 }
15263 return resultobj;
15264 fail:
15265 {
15266 if (temp2)
15267 delete arg2;
15268 }
15269 return NULL;
15270 }
15271
15272
15273 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15274 PyObject *resultobj = 0;
15275 wxImage *arg1 = (wxImage *) 0 ;
15276 wxString *arg2 = 0 ;
15277 wxString *arg3 = 0 ;
15278 int arg4 = (int) -1 ;
15279 bool result;
15280 void *argp1 = 0 ;
15281 int res1 = 0 ;
15282 bool temp2 = false ;
15283 bool temp3 = false ;
15284 int val4 ;
15285 int ecode4 = 0 ;
15286 PyObject * obj0 = 0 ;
15287 PyObject * obj1 = 0 ;
15288 PyObject * obj2 = 0 ;
15289 PyObject * obj3 = 0 ;
15290 char * kwnames[] = {
15291 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15292 };
15293
15294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15296 if (!SWIG_IsOK(res1)) {
15297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15298 }
15299 arg1 = reinterpret_cast< wxImage * >(argp1);
15300 {
15301 arg2 = wxString_in_helper(obj1);
15302 if (arg2 == NULL) SWIG_fail;
15303 temp2 = true;
15304 }
15305 {
15306 arg3 = wxString_in_helper(obj2);
15307 if (arg3 == NULL) SWIG_fail;
15308 temp3 = true;
15309 }
15310 if (obj3) {
15311 ecode4 = SWIG_AsVal_int(obj3, &val4);
15312 if (!SWIG_IsOK(ecode4)) {
15313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15314 }
15315 arg4 = static_cast< int >(val4);
15316 }
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 {
15324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15325 }
15326 {
15327 if (temp2)
15328 delete arg2;
15329 }
15330 {
15331 if (temp3)
15332 delete arg3;
15333 }
15334 return resultobj;
15335 fail:
15336 {
15337 if (temp2)
15338 delete arg2;
15339 }
15340 {
15341 if (temp3)
15342 delete arg3;
15343 }
15344 return NULL;
15345 }
15346
15347
15348 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj = 0;
15350 wxImage *arg1 = (wxImage *) 0 ;
15351 wxString *arg2 = 0 ;
15352 int arg3 ;
15353 bool result;
15354 void *argp1 = 0 ;
15355 int res1 = 0 ;
15356 bool temp2 = false ;
15357 int val3 ;
15358 int ecode3 = 0 ;
15359 PyObject * obj0 = 0 ;
15360 PyObject * obj1 = 0 ;
15361 PyObject * obj2 = 0 ;
15362 char * kwnames[] = {
15363 (char *) "self",(char *) "name",(char *) "type", NULL
15364 };
15365
15366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15368 if (!SWIG_IsOK(res1)) {
15369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15370 }
15371 arg1 = reinterpret_cast< wxImage * >(argp1);
15372 {
15373 arg2 = wxString_in_helper(obj1);
15374 if (arg2 == NULL) SWIG_fail;
15375 temp2 = true;
15376 }
15377 ecode3 = SWIG_AsVal_int(obj2, &val3);
15378 if (!SWIG_IsOK(ecode3)) {
15379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15380 }
15381 arg3 = static_cast< int >(val3);
15382 {
15383 PyThreadState* __tstate = wxPyBeginAllowThreads();
15384 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15385 wxPyEndAllowThreads(__tstate);
15386 if (PyErr_Occurred()) SWIG_fail;
15387 }
15388 {
15389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15390 }
15391 {
15392 if (temp2)
15393 delete arg2;
15394 }
15395 return resultobj;
15396 fail:
15397 {
15398 if (temp2)
15399 delete arg2;
15400 }
15401 return NULL;
15402 }
15403
15404
15405 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15406 PyObject *resultobj = 0;
15407 wxImage *arg1 = (wxImage *) 0 ;
15408 wxString *arg2 = 0 ;
15409 wxString *arg3 = 0 ;
15410 bool result;
15411 void *argp1 = 0 ;
15412 int res1 = 0 ;
15413 bool temp2 = false ;
15414 bool temp3 = false ;
15415 PyObject * obj0 = 0 ;
15416 PyObject * obj1 = 0 ;
15417 PyObject * obj2 = 0 ;
15418 char * kwnames[] = {
15419 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15420 };
15421
15422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15426 }
15427 arg1 = reinterpret_cast< wxImage * >(argp1);
15428 {
15429 arg2 = wxString_in_helper(obj1);
15430 if (arg2 == NULL) SWIG_fail;
15431 temp2 = true;
15432 }
15433 {
15434 arg3 = wxString_in_helper(obj2);
15435 if (arg3 == NULL) SWIG_fail;
15436 temp3 = true;
15437 }
15438 {
15439 PyThreadState* __tstate = wxPyBeginAllowThreads();
15440 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15441 wxPyEndAllowThreads(__tstate);
15442 if (PyErr_Occurred()) SWIG_fail;
15443 }
15444 {
15445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15446 }
15447 {
15448 if (temp2)
15449 delete arg2;
15450 }
15451 {
15452 if (temp3)
15453 delete arg3;
15454 }
15455 return resultobj;
15456 fail:
15457 {
15458 if (temp2)
15459 delete arg2;
15460 }
15461 {
15462 if (temp3)
15463 delete arg3;
15464 }
15465 return NULL;
15466 }
15467
15468
15469 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15470 PyObject *resultobj = 0;
15471 wxInputStream *arg1 = 0 ;
15472 bool result;
15473 wxPyInputStream *temp1 ;
15474 bool created1 ;
15475 PyObject * obj0 = 0 ;
15476 char * kwnames[] = {
15477 (char *) "stream", NULL
15478 };
15479
15480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15481 {
15482 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15483 arg1 = temp1->m_wxis;
15484 created1 = false;
15485 } else {
15486 PyErr_Clear(); // clear the failure of the wxPyConvert above
15487 arg1 = wxPyCBInputStream_create(obj0, false);
15488 if (arg1 == NULL) {
15489 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15490 SWIG_fail;
15491 }
15492 created1 = true;
15493 }
15494 }
15495 {
15496 PyThreadState* __tstate = wxPyBeginAllowThreads();
15497 result = (bool)wxImage::CanRead(*arg1);
15498 wxPyEndAllowThreads(__tstate);
15499 if (PyErr_Occurred()) SWIG_fail;
15500 }
15501 {
15502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15503 }
15504 {
15505 if (created1) delete arg1;
15506 }
15507 return resultobj;
15508 fail:
15509 {
15510 if (created1) delete arg1;
15511 }
15512 return NULL;
15513 }
15514
15515
15516 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15517 PyObject *resultobj = 0;
15518 wxImage *arg1 = (wxImage *) 0 ;
15519 wxInputStream *arg2 = 0 ;
15520 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15521 int arg4 = (int) -1 ;
15522 bool result;
15523 void *argp1 = 0 ;
15524 int res1 = 0 ;
15525 wxPyInputStream *temp2 ;
15526 bool created2 ;
15527 long val3 ;
15528 int ecode3 = 0 ;
15529 int val4 ;
15530 int ecode4 = 0 ;
15531 PyObject * obj0 = 0 ;
15532 PyObject * obj1 = 0 ;
15533 PyObject * obj2 = 0 ;
15534 PyObject * obj3 = 0 ;
15535 char * kwnames[] = {
15536 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15537 };
15538
15539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15541 if (!SWIG_IsOK(res1)) {
15542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15543 }
15544 arg1 = reinterpret_cast< wxImage * >(argp1);
15545 {
15546 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15547 arg2 = temp2->m_wxis;
15548 created2 = false;
15549 } else {
15550 PyErr_Clear(); // clear the failure of the wxPyConvert above
15551 arg2 = wxPyCBInputStream_create(obj1, false);
15552 if (arg2 == NULL) {
15553 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15554 SWIG_fail;
15555 }
15556 created2 = true;
15557 }
15558 }
15559 if (obj2) {
15560 ecode3 = SWIG_AsVal_long(obj2, &val3);
15561 if (!SWIG_IsOK(ecode3)) {
15562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15563 }
15564 arg3 = static_cast< long >(val3);
15565 }
15566 if (obj3) {
15567 ecode4 = SWIG_AsVal_int(obj3, &val4);
15568 if (!SWIG_IsOK(ecode4)) {
15569 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15570 }
15571 arg4 = static_cast< int >(val4);
15572 }
15573 {
15574 PyThreadState* __tstate = wxPyBeginAllowThreads();
15575 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15576 wxPyEndAllowThreads(__tstate);
15577 if (PyErr_Occurred()) SWIG_fail;
15578 }
15579 {
15580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15581 }
15582 {
15583 if (created2) delete arg2;
15584 }
15585 return resultobj;
15586 fail:
15587 {
15588 if (created2) delete arg2;
15589 }
15590 return NULL;
15591 }
15592
15593
15594 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15595 PyObject *resultobj = 0;
15596 wxImage *arg1 = (wxImage *) 0 ;
15597 wxInputStream *arg2 = 0 ;
15598 wxString *arg3 = 0 ;
15599 int arg4 = (int) -1 ;
15600 bool result;
15601 void *argp1 = 0 ;
15602 int res1 = 0 ;
15603 wxPyInputStream *temp2 ;
15604 bool created2 ;
15605 bool temp3 = false ;
15606 int val4 ;
15607 int ecode4 = 0 ;
15608 PyObject * obj0 = 0 ;
15609 PyObject * obj1 = 0 ;
15610 PyObject * obj2 = 0 ;
15611 PyObject * obj3 = 0 ;
15612 char * kwnames[] = {
15613 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15614 };
15615
15616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15618 if (!SWIG_IsOK(res1)) {
15619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15620 }
15621 arg1 = reinterpret_cast< wxImage * >(argp1);
15622 {
15623 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15624 arg2 = temp2->m_wxis;
15625 created2 = false;
15626 } else {
15627 PyErr_Clear(); // clear the failure of the wxPyConvert above
15628 arg2 = wxPyCBInputStream_create(obj1, false);
15629 if (arg2 == NULL) {
15630 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15631 SWIG_fail;
15632 }
15633 created2 = true;
15634 }
15635 }
15636 {
15637 arg3 = wxString_in_helper(obj2);
15638 if (arg3 == NULL) SWIG_fail;
15639 temp3 = true;
15640 }
15641 if (obj3) {
15642 ecode4 = SWIG_AsVal_int(obj3, &val4);
15643 if (!SWIG_IsOK(ecode4)) {
15644 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15645 }
15646 arg4 = static_cast< int >(val4);
15647 }
15648 {
15649 PyThreadState* __tstate = wxPyBeginAllowThreads();
15650 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15651 wxPyEndAllowThreads(__tstate);
15652 if (PyErr_Occurred()) SWIG_fail;
15653 }
15654 {
15655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15656 }
15657 {
15658 if (created2) delete arg2;
15659 }
15660 {
15661 if (temp3)
15662 delete arg3;
15663 }
15664 return resultobj;
15665 fail:
15666 {
15667 if (created2) delete arg2;
15668 }
15669 {
15670 if (temp3)
15671 delete arg3;
15672 }
15673 return NULL;
15674 }
15675
15676
15677 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15678 PyObject *resultobj = 0;
15679 wxImage *arg1 = (wxImage *) 0 ;
15680 bool result;
15681 void *argp1 = 0 ;
15682 int res1 = 0 ;
15683 PyObject *swig_obj[1] ;
15684
15685 if (!args) SWIG_fail;
15686 swig_obj[0] = args;
15687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15688 if (!SWIG_IsOK(res1)) {
15689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
15690 }
15691 arg1 = reinterpret_cast< wxImage * >(argp1);
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 result = (bool)(arg1)->IsOk();
15695 wxPyEndAllowThreads(__tstate);
15696 if (PyErr_Occurred()) SWIG_fail;
15697 }
15698 {
15699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15700 }
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15708 PyObject *resultobj = 0;
15709 wxImage *arg1 = (wxImage *) 0 ;
15710 int result;
15711 void *argp1 = 0 ;
15712 int res1 = 0 ;
15713 PyObject *swig_obj[1] ;
15714
15715 if (!args) SWIG_fail;
15716 swig_obj[0] = args;
15717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15718 if (!SWIG_IsOK(res1)) {
15719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15720 }
15721 arg1 = reinterpret_cast< wxImage * >(argp1);
15722 {
15723 PyThreadState* __tstate = wxPyBeginAllowThreads();
15724 result = (int)(arg1)->GetWidth();
15725 wxPyEndAllowThreads(__tstate);
15726 if (PyErr_Occurred()) SWIG_fail;
15727 }
15728 resultobj = SWIG_From_int(static_cast< int >(result));
15729 return resultobj;
15730 fail:
15731 return NULL;
15732 }
15733
15734
15735 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15736 PyObject *resultobj = 0;
15737 wxImage *arg1 = (wxImage *) 0 ;
15738 int result;
15739 void *argp1 = 0 ;
15740 int res1 = 0 ;
15741 PyObject *swig_obj[1] ;
15742
15743 if (!args) SWIG_fail;
15744 swig_obj[0] = args;
15745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15746 if (!SWIG_IsOK(res1)) {
15747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15748 }
15749 arg1 = reinterpret_cast< wxImage * >(argp1);
15750 {
15751 PyThreadState* __tstate = wxPyBeginAllowThreads();
15752 result = (int)(arg1)->GetHeight();
15753 wxPyEndAllowThreads(__tstate);
15754 if (PyErr_Occurred()) SWIG_fail;
15755 }
15756 resultobj = SWIG_From_int(static_cast< int >(result));
15757 return resultobj;
15758 fail:
15759 return NULL;
15760 }
15761
15762
15763 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15764 PyObject *resultobj = 0;
15765 wxImage *arg1 = (wxImage *) 0 ;
15766 wxSize result;
15767 void *argp1 = 0 ;
15768 int res1 = 0 ;
15769 PyObject *swig_obj[1] ;
15770
15771 if (!args) SWIG_fail;
15772 swig_obj[0] = args;
15773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15774 if (!SWIG_IsOK(res1)) {
15775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15776 }
15777 arg1 = reinterpret_cast< wxImage * >(argp1);
15778 {
15779 PyThreadState* __tstate = wxPyBeginAllowThreads();
15780 result = wxImage_GetSize(arg1);
15781 wxPyEndAllowThreads(__tstate);
15782 if (PyErr_Occurred()) SWIG_fail;
15783 }
15784 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15785 return resultobj;
15786 fail:
15787 return NULL;
15788 }
15789
15790
15791 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15792 PyObject *resultobj = 0;
15793 wxImage *arg1 = (wxImage *) 0 ;
15794 wxRect *arg2 = 0 ;
15795 SwigValueWrapper<wxImage > result;
15796 void *argp1 = 0 ;
15797 int res1 = 0 ;
15798 wxRect temp2 ;
15799 PyObject * obj0 = 0 ;
15800 PyObject * obj1 = 0 ;
15801 char * kwnames[] = {
15802 (char *) "self",(char *) "rect", NULL
15803 };
15804
15805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15807 if (!SWIG_IsOK(res1)) {
15808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15809 }
15810 arg1 = reinterpret_cast< wxImage * >(argp1);
15811 {
15812 arg2 = &temp2;
15813 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15814 }
15815 {
15816 PyThreadState* __tstate = wxPyBeginAllowThreads();
15817 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15818 wxPyEndAllowThreads(__tstate);
15819 if (PyErr_Occurred()) SWIG_fail;
15820 }
15821 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15822 return resultobj;
15823 fail:
15824 return NULL;
15825 }
15826
15827
15828 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15829 PyObject *resultobj = 0;
15830 wxImage *arg1 = (wxImage *) 0 ;
15831 wxSize *arg2 = 0 ;
15832 wxPoint *arg3 = 0 ;
15833 int arg4 = (int) -1 ;
15834 int arg5 = (int) -1 ;
15835 int arg6 = (int) -1 ;
15836 SwigValueWrapper<wxImage > result;
15837 void *argp1 = 0 ;
15838 int res1 = 0 ;
15839 wxSize temp2 ;
15840 wxPoint temp3 ;
15841 int val4 ;
15842 int ecode4 = 0 ;
15843 int val5 ;
15844 int ecode5 = 0 ;
15845 int val6 ;
15846 int ecode6 = 0 ;
15847 PyObject * obj0 = 0 ;
15848 PyObject * obj1 = 0 ;
15849 PyObject * obj2 = 0 ;
15850 PyObject * obj3 = 0 ;
15851 PyObject * obj4 = 0 ;
15852 PyObject * obj5 = 0 ;
15853 char * kwnames[] = {
15854 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15855 };
15856
15857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15859 if (!SWIG_IsOK(res1)) {
15860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15861 }
15862 arg1 = reinterpret_cast< wxImage * >(argp1);
15863 {
15864 arg2 = &temp2;
15865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15866 }
15867 {
15868 arg3 = &temp3;
15869 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15870 }
15871 if (obj3) {
15872 ecode4 = SWIG_AsVal_int(obj3, &val4);
15873 if (!SWIG_IsOK(ecode4)) {
15874 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15875 }
15876 arg4 = static_cast< int >(val4);
15877 }
15878 if (obj4) {
15879 ecode5 = SWIG_AsVal_int(obj4, &val5);
15880 if (!SWIG_IsOK(ecode5)) {
15881 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15882 }
15883 arg5 = static_cast< int >(val5);
15884 }
15885 if (obj5) {
15886 ecode6 = SWIG_AsVal_int(obj5, &val6);
15887 if (!SWIG_IsOK(ecode6)) {
15888 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15889 }
15890 arg6 = static_cast< int >(val6);
15891 }
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15906 PyObject *resultobj = 0;
15907 wxImage *arg1 = (wxImage *) 0 ;
15908 SwigValueWrapper<wxImage > result;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 PyObject *swig_obj[1] ;
15912
15913 if (!args) SWIG_fail;
15914 swig_obj[0] = args;
15915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15916 if (!SWIG_IsOK(res1)) {
15917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15918 }
15919 arg1 = reinterpret_cast< wxImage * >(argp1);
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (arg1)->Copy();
15923 wxPyEndAllowThreads(__tstate);
15924 if (PyErr_Occurred()) SWIG_fail;
15925 }
15926 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15934 PyObject *resultobj = 0;
15935 wxImage *arg1 = (wxImage *) 0 ;
15936 wxImage *arg2 = 0 ;
15937 int arg3 ;
15938 int arg4 ;
15939 void *argp1 = 0 ;
15940 int res1 = 0 ;
15941 void *argp2 = 0 ;
15942 int res2 = 0 ;
15943 int val3 ;
15944 int ecode3 = 0 ;
15945 int val4 ;
15946 int ecode4 = 0 ;
15947 PyObject * obj0 = 0 ;
15948 PyObject * obj1 = 0 ;
15949 PyObject * obj2 = 0 ;
15950 PyObject * obj3 = 0 ;
15951 char * kwnames[] = {
15952 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15953 };
15954
15955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15957 if (!SWIG_IsOK(res1)) {
15958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15959 }
15960 arg1 = reinterpret_cast< wxImage * >(argp1);
15961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15962 if (!SWIG_IsOK(res2)) {
15963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15964 }
15965 if (!argp2) {
15966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15967 }
15968 arg2 = reinterpret_cast< wxImage * >(argp2);
15969 ecode3 = SWIG_AsVal_int(obj2, &val3);
15970 if (!SWIG_IsOK(ecode3)) {
15971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15972 }
15973 arg3 = static_cast< int >(val3);
15974 ecode4 = SWIG_AsVal_int(obj3, &val4);
15975 if (!SWIG_IsOK(ecode4)) {
15976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15977 }
15978 arg4 = static_cast< int >(val4);
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15982 wxPyEndAllowThreads(__tstate);
15983 if (PyErr_Occurred()) SWIG_fail;
15984 }
15985 resultobj = SWIG_Py_Void();
15986 return resultobj;
15987 fail:
15988 return NULL;
15989 }
15990
15991
15992 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15993 PyObject *resultobj = 0;
15994 wxImage *arg1 = (wxImage *) 0 ;
15995 PyObject *result = 0 ;
15996 void *argp1 = 0 ;
15997 int res1 = 0 ;
15998 PyObject *swig_obj[1] ;
15999
16000 if (!args) SWIG_fail;
16001 swig_obj[0] = args;
16002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16003 if (!SWIG_IsOK(res1)) {
16004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
16005 }
16006 arg1 = reinterpret_cast< wxImage * >(argp1);
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 result = (PyObject *)wxImage_GetData(arg1);
16010 wxPyEndAllowThreads(__tstate);
16011 if (PyErr_Occurred()) SWIG_fail;
16012 }
16013 resultobj = result;
16014 return resultobj;
16015 fail:
16016 return NULL;
16017 }
16018
16019
16020 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16021 PyObject *resultobj = 0;
16022 wxImage *arg1 = (wxImage *) 0 ;
16023 buffer arg2 ;
16024 int arg3 ;
16025 void *argp1 = 0 ;
16026 int res1 = 0 ;
16027 Py_ssize_t temp2 ;
16028 PyObject * obj0 = 0 ;
16029 PyObject * obj1 = 0 ;
16030 char * kwnames[] = {
16031 (char *) "self",(char *) "data", NULL
16032 };
16033
16034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16036 if (!SWIG_IsOK(res1)) {
16037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16038 }
16039 arg1 = reinterpret_cast< wxImage * >(argp1);
16040 {
16041 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16042 arg3 = (int)temp2;
16043 }
16044 {
16045 PyThreadState* __tstate = wxPyBeginAllowThreads();
16046 wxImage_SetData(arg1,arg2,arg3);
16047 wxPyEndAllowThreads(__tstate);
16048 if (PyErr_Occurred()) SWIG_fail;
16049 }
16050 resultobj = SWIG_Py_Void();
16051 return resultobj;
16052 fail:
16053 return NULL;
16054 }
16055
16056
16057 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16058 PyObject *resultobj = 0;
16059 wxImage *arg1 = (wxImage *) 0 ;
16060 PyObject *result = 0 ;
16061 void *argp1 = 0 ;
16062 int res1 = 0 ;
16063 PyObject *swig_obj[1] ;
16064
16065 if (!args) SWIG_fail;
16066 swig_obj[0] = args;
16067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16068 if (!SWIG_IsOK(res1)) {
16069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16070 }
16071 arg1 = reinterpret_cast< wxImage * >(argp1);
16072 {
16073 PyThreadState* __tstate = wxPyBeginAllowThreads();
16074 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16075 wxPyEndAllowThreads(__tstate);
16076 if (PyErr_Occurred()) SWIG_fail;
16077 }
16078 resultobj = result;
16079 return resultobj;
16080 fail:
16081 return NULL;
16082 }
16083
16084
16085 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16086 PyObject *resultobj = 0;
16087 wxImage *arg1 = (wxImage *) 0 ;
16088 buffer arg2 ;
16089 int arg3 ;
16090 void *argp1 = 0 ;
16091 int res1 = 0 ;
16092 Py_ssize_t temp2 ;
16093 PyObject * obj0 = 0 ;
16094 PyObject * obj1 = 0 ;
16095 char * kwnames[] = {
16096 (char *) "self",(char *) "data", NULL
16097 };
16098
16099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16101 if (!SWIG_IsOK(res1)) {
16102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16103 }
16104 arg1 = reinterpret_cast< wxImage * >(argp1);
16105 {
16106 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16107 arg3 = (int)temp2;
16108 }
16109 {
16110 PyThreadState* __tstate = wxPyBeginAllowThreads();
16111 wxImage_SetDataBuffer(arg1,arg2,arg3);
16112 wxPyEndAllowThreads(__tstate);
16113 if (PyErr_Occurred()) SWIG_fail;
16114 }
16115 resultobj = SWIG_Py_Void();
16116 return resultobj;
16117 fail:
16118 return NULL;
16119 }
16120
16121
16122 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16123 PyObject *resultobj = 0;
16124 wxImage *arg1 = (wxImage *) 0 ;
16125 PyObject *result = 0 ;
16126 void *argp1 = 0 ;
16127 int res1 = 0 ;
16128 PyObject *swig_obj[1] ;
16129
16130 if (!args) SWIG_fail;
16131 swig_obj[0] = args;
16132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16133 if (!SWIG_IsOK(res1)) {
16134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16135 }
16136 arg1 = reinterpret_cast< wxImage * >(argp1);
16137 {
16138 PyThreadState* __tstate = wxPyBeginAllowThreads();
16139 result = (PyObject *)wxImage_GetAlphaData(arg1);
16140 wxPyEndAllowThreads(__tstate);
16141 if (PyErr_Occurred()) SWIG_fail;
16142 }
16143 resultobj = result;
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj = 0;
16152 wxImage *arg1 = (wxImage *) 0 ;
16153 buffer arg2 ;
16154 int arg3 ;
16155 void *argp1 = 0 ;
16156 int res1 = 0 ;
16157 Py_ssize_t temp2 ;
16158 PyObject * obj0 = 0 ;
16159 PyObject * obj1 = 0 ;
16160 char * kwnames[] = {
16161 (char *) "self",(char *) "alpha", NULL
16162 };
16163
16164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16166 if (!SWIG_IsOK(res1)) {
16167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16168 }
16169 arg1 = reinterpret_cast< wxImage * >(argp1);
16170 {
16171 if (obj1 != Py_None) {
16172 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16173 arg3 = (int)temp2;
16174 }
16175 }
16176 {
16177 PyThreadState* __tstate = wxPyBeginAllowThreads();
16178 wxImage_SetAlphaData(arg1,arg2,arg3);
16179 wxPyEndAllowThreads(__tstate);
16180 if (PyErr_Occurred()) SWIG_fail;
16181 }
16182 resultobj = SWIG_Py_Void();
16183 return resultobj;
16184 fail:
16185 return NULL;
16186 }
16187
16188
16189 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16190 PyObject *resultobj = 0;
16191 wxImage *arg1 = (wxImage *) 0 ;
16192 PyObject *result = 0 ;
16193 void *argp1 = 0 ;
16194 int res1 = 0 ;
16195 PyObject *swig_obj[1] ;
16196
16197 if (!args) SWIG_fail;
16198 swig_obj[0] = args;
16199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16200 if (!SWIG_IsOK(res1)) {
16201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16202 }
16203 arg1 = reinterpret_cast< wxImage * >(argp1);
16204 {
16205 PyThreadState* __tstate = wxPyBeginAllowThreads();
16206 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16207 wxPyEndAllowThreads(__tstate);
16208 if (PyErr_Occurred()) SWIG_fail;
16209 }
16210 resultobj = result;
16211 return resultobj;
16212 fail:
16213 return NULL;
16214 }
16215
16216
16217 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16218 PyObject *resultobj = 0;
16219 wxImage *arg1 = (wxImage *) 0 ;
16220 buffer arg2 ;
16221 int arg3 ;
16222 void *argp1 = 0 ;
16223 int res1 = 0 ;
16224 Py_ssize_t temp2 ;
16225 PyObject * obj0 = 0 ;
16226 PyObject * obj1 = 0 ;
16227 char * kwnames[] = {
16228 (char *) "self",(char *) "alpha", NULL
16229 };
16230
16231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16233 if (!SWIG_IsOK(res1)) {
16234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16235 }
16236 arg1 = reinterpret_cast< wxImage * >(argp1);
16237 {
16238 if (obj1 != Py_None) {
16239 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16240 arg3 = (int)temp2;
16241 }
16242 }
16243 {
16244 PyThreadState* __tstate = wxPyBeginAllowThreads();
16245 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16246 wxPyEndAllowThreads(__tstate);
16247 if (PyErr_Occurred()) SWIG_fail;
16248 }
16249 resultobj = SWIG_Py_Void();
16250 return resultobj;
16251 fail:
16252 return NULL;
16253 }
16254
16255
16256 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16257 PyObject *resultobj = 0;
16258 wxImage *arg1 = (wxImage *) 0 ;
16259 byte arg2 ;
16260 byte arg3 ;
16261 byte arg4 ;
16262 void *argp1 = 0 ;
16263 int res1 = 0 ;
16264 unsigned char val2 ;
16265 int ecode2 = 0 ;
16266 unsigned char val3 ;
16267 int ecode3 = 0 ;
16268 unsigned char val4 ;
16269 int ecode4 = 0 ;
16270 PyObject * obj0 = 0 ;
16271 PyObject * obj1 = 0 ;
16272 PyObject * obj2 = 0 ;
16273 PyObject * obj3 = 0 ;
16274 char * kwnames[] = {
16275 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16276 };
16277
16278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16280 if (!SWIG_IsOK(res1)) {
16281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16282 }
16283 arg1 = reinterpret_cast< wxImage * >(argp1);
16284 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16285 if (!SWIG_IsOK(ecode2)) {
16286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16287 }
16288 arg2 = static_cast< byte >(val2);
16289 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16290 if (!SWIG_IsOK(ecode3)) {
16291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16292 }
16293 arg3 = static_cast< byte >(val3);
16294 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16295 if (!SWIG_IsOK(ecode4)) {
16296 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16297 }
16298 arg4 = static_cast< byte >(val4);
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 (arg1)->SetMaskColour(arg2,arg3,arg4);
16302 wxPyEndAllowThreads(__tstate);
16303 if (PyErr_Occurred()) SWIG_fail;
16304 }
16305 resultobj = SWIG_Py_Void();
16306 return resultobj;
16307 fail:
16308 return NULL;
16309 }
16310
16311
16312 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16313 PyObject *resultobj = 0;
16314 wxImage *arg1 = (wxImage *) 0 ;
16315 byte *arg2 = (byte *) 0 ;
16316 byte *arg3 = (byte *) 0 ;
16317 byte *arg4 = (byte *) 0 ;
16318 void *argp1 = 0 ;
16319 int res1 = 0 ;
16320 byte temp2 ;
16321 int res2 = SWIG_TMPOBJ ;
16322 byte temp3 ;
16323 int res3 = SWIG_TMPOBJ ;
16324 byte temp4 ;
16325 int res4 = SWIG_TMPOBJ ;
16326 PyObject *swig_obj[1] ;
16327
16328 arg2 = &temp2;
16329 arg3 = &temp3;
16330 arg4 = &temp4;
16331 if (!args) SWIG_fail;
16332 swig_obj[0] = args;
16333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16334 if (!SWIG_IsOK(res1)) {
16335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16336 }
16337 arg1 = reinterpret_cast< wxImage * >(argp1);
16338 {
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 resultobj = SWIG_Py_Void();
16345 if (SWIG_IsTmpObj(res2)) {
16346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16347 } else {
16348 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16350 }
16351 if (SWIG_IsTmpObj(res3)) {
16352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16353 } else {
16354 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16356 }
16357 if (SWIG_IsTmpObj(res4)) {
16358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16359 } else {
16360 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16362 }
16363 return resultobj;
16364 fail:
16365 return NULL;
16366 }
16367
16368
16369 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16370 PyObject *resultobj = 0;
16371 wxImage *arg1 = (wxImage *) 0 ;
16372 byte result;
16373 void *argp1 = 0 ;
16374 int res1 = 0 ;
16375 PyObject *swig_obj[1] ;
16376
16377 if (!args) SWIG_fail;
16378 swig_obj[0] = args;
16379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16380 if (!SWIG_IsOK(res1)) {
16381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16382 }
16383 arg1 = reinterpret_cast< wxImage * >(argp1);
16384 {
16385 PyThreadState* __tstate = wxPyBeginAllowThreads();
16386 result = (byte)(arg1)->GetMaskRed();
16387 wxPyEndAllowThreads(__tstate);
16388 if (PyErr_Occurred()) SWIG_fail;
16389 }
16390 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16398 PyObject *resultobj = 0;
16399 wxImage *arg1 = (wxImage *) 0 ;
16400 byte result;
16401 void *argp1 = 0 ;
16402 int res1 = 0 ;
16403 PyObject *swig_obj[1] ;
16404
16405 if (!args) SWIG_fail;
16406 swig_obj[0] = args;
16407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16408 if (!SWIG_IsOK(res1)) {
16409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16410 }
16411 arg1 = reinterpret_cast< wxImage * >(argp1);
16412 {
16413 PyThreadState* __tstate = wxPyBeginAllowThreads();
16414 result = (byte)(arg1)->GetMaskGreen();
16415 wxPyEndAllowThreads(__tstate);
16416 if (PyErr_Occurred()) SWIG_fail;
16417 }
16418 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16419 return resultobj;
16420 fail:
16421 return NULL;
16422 }
16423
16424
16425 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16426 PyObject *resultobj = 0;
16427 wxImage *arg1 = (wxImage *) 0 ;
16428 byte result;
16429 void *argp1 = 0 ;
16430 int res1 = 0 ;
16431 PyObject *swig_obj[1] ;
16432
16433 if (!args) SWIG_fail;
16434 swig_obj[0] = args;
16435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16436 if (!SWIG_IsOK(res1)) {
16437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16438 }
16439 arg1 = reinterpret_cast< wxImage * >(argp1);
16440 {
16441 PyThreadState* __tstate = wxPyBeginAllowThreads();
16442 result = (byte)(arg1)->GetMaskBlue();
16443 wxPyEndAllowThreads(__tstate);
16444 if (PyErr_Occurred()) SWIG_fail;
16445 }
16446 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16447 return resultobj;
16448 fail:
16449 return NULL;
16450 }
16451
16452
16453 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj = 0;
16455 wxImage *arg1 = (wxImage *) 0 ;
16456 bool arg2 = (bool) true ;
16457 void *argp1 = 0 ;
16458 int res1 = 0 ;
16459 bool val2 ;
16460 int ecode2 = 0 ;
16461 PyObject * obj0 = 0 ;
16462 PyObject * obj1 = 0 ;
16463 char * kwnames[] = {
16464 (char *) "self",(char *) "mask", NULL
16465 };
16466
16467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",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_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16471 }
16472 arg1 = reinterpret_cast< wxImage * >(argp1);
16473 if (obj1) {
16474 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16475 if (!SWIG_IsOK(ecode2)) {
16476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16477 }
16478 arg2 = static_cast< bool >(val2);
16479 }
16480 {
16481 PyThreadState* __tstate = wxPyBeginAllowThreads();
16482 (arg1)->SetMask(arg2);
16483 wxPyEndAllowThreads(__tstate);
16484 if (PyErr_Occurred()) SWIG_fail;
16485 }
16486 resultobj = SWIG_Py_Void();
16487 return resultobj;
16488 fail:
16489 return NULL;
16490 }
16491
16492
16493 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16494 PyObject *resultobj = 0;
16495 wxImage *arg1 = (wxImage *) 0 ;
16496 bool result;
16497 void *argp1 = 0 ;
16498 int res1 = 0 ;
16499 PyObject *swig_obj[1] ;
16500
16501 if (!args) SWIG_fail;
16502 swig_obj[0] = args;
16503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16504 if (!SWIG_IsOK(res1)) {
16505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16506 }
16507 arg1 = reinterpret_cast< wxImage * >(argp1);
16508 {
16509 PyThreadState* __tstate = wxPyBeginAllowThreads();
16510 result = (bool)(arg1)->HasMask();
16511 wxPyEndAllowThreads(__tstate);
16512 if (PyErr_Occurred()) SWIG_fail;
16513 }
16514 {
16515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16516 }
16517 return resultobj;
16518 fail:
16519 return NULL;
16520 }
16521
16522
16523 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16524 PyObject *resultobj = 0;
16525 wxImage *arg1 = (wxImage *) 0 ;
16526 double arg2 ;
16527 wxPoint *arg3 = 0 ;
16528 bool arg4 = (bool) true ;
16529 wxPoint *arg5 = (wxPoint *) NULL ;
16530 SwigValueWrapper<wxImage > result;
16531 void *argp1 = 0 ;
16532 int res1 = 0 ;
16533 double val2 ;
16534 int ecode2 = 0 ;
16535 wxPoint temp3 ;
16536 bool val4 ;
16537 int ecode4 = 0 ;
16538 void *argp5 = 0 ;
16539 int res5 = 0 ;
16540 PyObject * obj0 = 0 ;
16541 PyObject * obj1 = 0 ;
16542 PyObject * obj2 = 0 ;
16543 PyObject * obj3 = 0 ;
16544 PyObject * obj4 = 0 ;
16545 char * kwnames[] = {
16546 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16547 };
16548
16549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16551 if (!SWIG_IsOK(res1)) {
16552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16553 }
16554 arg1 = reinterpret_cast< wxImage * >(argp1);
16555 ecode2 = SWIG_AsVal_double(obj1, &val2);
16556 if (!SWIG_IsOK(ecode2)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16558 }
16559 arg2 = static_cast< double >(val2);
16560 {
16561 arg3 = &temp3;
16562 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16563 }
16564 if (obj3) {
16565 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16566 if (!SWIG_IsOK(ecode4)) {
16567 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16568 }
16569 arg4 = static_cast< bool >(val4);
16570 }
16571 if (obj4) {
16572 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16573 if (!SWIG_IsOK(res5)) {
16574 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16575 }
16576 arg5 = reinterpret_cast< wxPoint * >(argp5);
16577 }
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj = 0;
16593 wxImage *arg1 = (wxImage *) 0 ;
16594 bool arg2 = (bool) true ;
16595 SwigValueWrapper<wxImage > result;
16596 void *argp1 = 0 ;
16597 int res1 = 0 ;
16598 bool val2 ;
16599 int ecode2 = 0 ;
16600 PyObject * obj0 = 0 ;
16601 PyObject * obj1 = 0 ;
16602 char * kwnames[] = {
16603 (char *) "self",(char *) "clockwise", NULL
16604 };
16605
16606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16608 if (!SWIG_IsOK(res1)) {
16609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16610 }
16611 arg1 = reinterpret_cast< wxImage * >(argp1);
16612 if (obj1) {
16613 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16614 if (!SWIG_IsOK(ecode2)) {
16615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16616 }
16617 arg2 = static_cast< bool >(val2);
16618 }
16619 {
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 result = (arg1)->Rotate90(arg2);
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj = 0;
16634 wxImage *arg1 = (wxImage *) 0 ;
16635 bool arg2 = (bool) true ;
16636 SwigValueWrapper<wxImage > result;
16637 void *argp1 = 0 ;
16638 int res1 = 0 ;
16639 bool val2 ;
16640 int ecode2 = 0 ;
16641 PyObject * obj0 = 0 ;
16642 PyObject * obj1 = 0 ;
16643 char * kwnames[] = {
16644 (char *) "self",(char *) "horizontally", NULL
16645 };
16646
16647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16649 if (!SWIG_IsOK(res1)) {
16650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16651 }
16652 arg1 = reinterpret_cast< wxImage * >(argp1);
16653 if (obj1) {
16654 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16655 if (!SWIG_IsOK(ecode2)) {
16656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16657 }
16658 arg2 = static_cast< bool >(val2);
16659 }
16660 {
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 result = (arg1)->Mirror(arg2);
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj = 0;
16675 wxImage *arg1 = (wxImage *) 0 ;
16676 byte arg2 ;
16677 byte arg3 ;
16678 byte arg4 ;
16679 byte arg5 ;
16680 byte arg6 ;
16681 byte arg7 ;
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 unsigned char val5 ;
16691 int ecode5 = 0 ;
16692 unsigned char val6 ;
16693 int ecode6 = 0 ;
16694 unsigned char val7 ;
16695 int ecode7 = 0 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 PyObject * obj2 = 0 ;
16699 PyObject * obj3 = 0 ;
16700 PyObject * obj4 = 0 ;
16701 PyObject * obj5 = 0 ;
16702 PyObject * obj6 = 0 ;
16703 char * kwnames[] = {
16704 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16705 };
16706
16707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16709 if (!SWIG_IsOK(res1)) {
16710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16711 }
16712 arg1 = reinterpret_cast< wxImage * >(argp1);
16713 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16714 if (!SWIG_IsOK(ecode2)) {
16715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16716 }
16717 arg2 = static_cast< byte >(val2);
16718 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16719 if (!SWIG_IsOK(ecode3)) {
16720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16721 }
16722 arg3 = static_cast< byte >(val3);
16723 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16724 if (!SWIG_IsOK(ecode4)) {
16725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16726 }
16727 arg4 = static_cast< byte >(val4);
16728 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16729 if (!SWIG_IsOK(ecode5)) {
16730 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16731 }
16732 arg5 = static_cast< byte >(val5);
16733 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16734 if (!SWIG_IsOK(ecode6)) {
16735 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16736 }
16737 arg6 = static_cast< byte >(val6);
16738 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16739 if (!SWIG_IsOK(ecode7)) {
16740 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16741 }
16742 arg7 = static_cast< byte >(val7);
16743 {
16744 PyThreadState* __tstate = wxPyBeginAllowThreads();
16745 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16746 wxPyEndAllowThreads(__tstate);
16747 if (PyErr_Occurred()) SWIG_fail;
16748 }
16749 resultobj = SWIG_Py_Void();
16750 return resultobj;
16751 fail:
16752 return NULL;
16753 }
16754
16755
16756 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj = 0;
16758 wxImage *arg1 = (wxImage *) 0 ;
16759 double arg2 = (double) 0.299 ;
16760 double arg3 = (double) 0.587 ;
16761 double arg4 = (double) 0.114 ;
16762 SwigValueWrapper<wxImage > result;
16763 void *argp1 = 0 ;
16764 int res1 = 0 ;
16765 double val2 ;
16766 int ecode2 = 0 ;
16767 double val3 ;
16768 int ecode3 = 0 ;
16769 double val4 ;
16770 int ecode4 = 0 ;
16771 PyObject * obj0 = 0 ;
16772 PyObject * obj1 = 0 ;
16773 PyObject * obj2 = 0 ;
16774 PyObject * obj3 = 0 ;
16775 char * kwnames[] = {
16776 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16777 };
16778
16779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16781 if (!SWIG_IsOK(res1)) {
16782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16783 }
16784 arg1 = reinterpret_cast< wxImage * >(argp1);
16785 if (obj1) {
16786 ecode2 = SWIG_AsVal_double(obj1, &val2);
16787 if (!SWIG_IsOK(ecode2)) {
16788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16789 }
16790 arg2 = static_cast< double >(val2);
16791 }
16792 if (obj2) {
16793 ecode3 = SWIG_AsVal_double(obj2, &val3);
16794 if (!SWIG_IsOK(ecode3)) {
16795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16796 }
16797 arg3 = static_cast< double >(val3);
16798 }
16799 if (obj3) {
16800 ecode4 = SWIG_AsVal_double(obj3, &val4);
16801 if (!SWIG_IsOK(ecode4)) {
16802 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16803 }
16804 arg4 = static_cast< double >(val4);
16805 }
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16820 PyObject *resultobj = 0;
16821 wxImage *arg1 = (wxImage *) 0 ;
16822 byte arg2 ;
16823 byte arg3 ;
16824 byte arg4 ;
16825 SwigValueWrapper<wxImage > result;
16826 void *argp1 = 0 ;
16827 int res1 = 0 ;
16828 unsigned char val2 ;
16829 int ecode2 = 0 ;
16830 unsigned char val3 ;
16831 int ecode3 = 0 ;
16832 unsigned char val4 ;
16833 int ecode4 = 0 ;
16834 PyObject * obj0 = 0 ;
16835 PyObject * obj1 = 0 ;
16836 PyObject * obj2 = 0 ;
16837 PyObject * obj3 = 0 ;
16838 char * kwnames[] = {
16839 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16840 };
16841
16842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16844 if (!SWIG_IsOK(res1)) {
16845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16846 }
16847 arg1 = reinterpret_cast< wxImage * >(argp1);
16848 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16849 if (!SWIG_IsOK(ecode2)) {
16850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16851 }
16852 arg2 = static_cast< byte >(val2);
16853 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16854 if (!SWIG_IsOK(ecode3)) {
16855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16856 }
16857 arg3 = static_cast< byte >(val3);
16858 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16859 if (!SWIG_IsOK(ecode4)) {
16860 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16861 }
16862 arg4 = static_cast< byte >(val4);
16863 {
16864 PyThreadState* __tstate = wxPyBeginAllowThreads();
16865 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16866 wxPyEndAllowThreads(__tstate);
16867 if (PyErr_Occurred()) SWIG_fail;
16868 }
16869 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16870 return resultobj;
16871 fail:
16872 return NULL;
16873 }
16874
16875
16876 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16877 PyObject *resultobj = 0;
16878 wxImage *arg1 = (wxImage *) 0 ;
16879 wxString *arg2 = 0 ;
16880 wxString *arg3 = 0 ;
16881 void *argp1 = 0 ;
16882 int res1 = 0 ;
16883 bool temp2 = false ;
16884 bool temp3 = false ;
16885 PyObject * obj0 = 0 ;
16886 PyObject * obj1 = 0 ;
16887 PyObject * obj2 = 0 ;
16888 char * kwnames[] = {
16889 (char *) "self",(char *) "name",(char *) "value", NULL
16890 };
16891
16892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16894 if (!SWIG_IsOK(res1)) {
16895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16896 }
16897 arg1 = reinterpret_cast< wxImage * >(argp1);
16898 {
16899 arg2 = wxString_in_helper(obj1);
16900 if (arg2 == NULL) SWIG_fail;
16901 temp2 = true;
16902 }
16903 {
16904 arg3 = wxString_in_helper(obj2);
16905 if (arg3 == NULL) SWIG_fail;
16906 temp3 = true;
16907 }
16908 {
16909 PyThreadState* __tstate = wxPyBeginAllowThreads();
16910 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16911 wxPyEndAllowThreads(__tstate);
16912 if (PyErr_Occurred()) SWIG_fail;
16913 }
16914 resultobj = SWIG_Py_Void();
16915 {
16916 if (temp2)
16917 delete arg2;
16918 }
16919 {
16920 if (temp3)
16921 delete arg3;
16922 }
16923 return resultobj;
16924 fail:
16925 {
16926 if (temp2)
16927 delete arg2;
16928 }
16929 {
16930 if (temp3)
16931 delete arg3;
16932 }
16933 return NULL;
16934 }
16935
16936
16937 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16938 PyObject *resultobj = 0;
16939 wxImage *arg1 = (wxImage *) 0 ;
16940 wxString *arg2 = 0 ;
16941 int arg3 ;
16942 void *argp1 = 0 ;
16943 int res1 = 0 ;
16944 bool temp2 = false ;
16945 int val3 ;
16946 int ecode3 = 0 ;
16947 PyObject * obj0 = 0 ;
16948 PyObject * obj1 = 0 ;
16949 PyObject * obj2 = 0 ;
16950 char * kwnames[] = {
16951 (char *) "self",(char *) "name",(char *) "value", NULL
16952 };
16953
16954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16956 if (!SWIG_IsOK(res1)) {
16957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16958 }
16959 arg1 = reinterpret_cast< wxImage * >(argp1);
16960 {
16961 arg2 = wxString_in_helper(obj1);
16962 if (arg2 == NULL) SWIG_fail;
16963 temp2 = true;
16964 }
16965 ecode3 = SWIG_AsVal_int(obj2, &val3);
16966 if (!SWIG_IsOK(ecode3)) {
16967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16968 }
16969 arg3 = static_cast< int >(val3);
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 (arg1)->SetOption((wxString const &)*arg2,arg3);
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 resultobj = SWIG_Py_Void();
16977 {
16978 if (temp2)
16979 delete arg2;
16980 }
16981 return resultobj;
16982 fail:
16983 {
16984 if (temp2)
16985 delete arg2;
16986 }
16987 return NULL;
16988 }
16989
16990
16991 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16992 PyObject *resultobj = 0;
16993 wxImage *arg1 = (wxImage *) 0 ;
16994 wxString *arg2 = 0 ;
16995 wxString result;
16996 void *argp1 = 0 ;
16997 int res1 = 0 ;
16998 bool temp2 = false ;
16999 PyObject * obj0 = 0 ;
17000 PyObject * obj1 = 0 ;
17001 char * kwnames[] = {
17002 (char *) "self",(char *) "name", NULL
17003 };
17004
17005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
17006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17007 if (!SWIG_IsOK(res1)) {
17008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17009 }
17010 arg1 = reinterpret_cast< wxImage * >(argp1);
17011 {
17012 arg2 = wxString_in_helper(obj1);
17013 if (arg2 == NULL) SWIG_fail;
17014 temp2 = true;
17015 }
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17019 wxPyEndAllowThreads(__tstate);
17020 if (PyErr_Occurred()) SWIG_fail;
17021 }
17022 {
17023 #if wxUSE_UNICODE
17024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17025 #else
17026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17027 #endif
17028 }
17029 {
17030 if (temp2)
17031 delete arg2;
17032 }
17033 return resultobj;
17034 fail:
17035 {
17036 if (temp2)
17037 delete arg2;
17038 }
17039 return NULL;
17040 }
17041
17042
17043 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17044 PyObject *resultobj = 0;
17045 wxImage *arg1 = (wxImage *) 0 ;
17046 wxString *arg2 = 0 ;
17047 int result;
17048 void *argp1 = 0 ;
17049 int res1 = 0 ;
17050 bool temp2 = false ;
17051 PyObject * obj0 = 0 ;
17052 PyObject * obj1 = 0 ;
17053 char * kwnames[] = {
17054 (char *) "self",(char *) "name", NULL
17055 };
17056
17057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17059 if (!SWIG_IsOK(res1)) {
17060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17061 }
17062 arg1 = reinterpret_cast< wxImage * >(argp1);
17063 {
17064 arg2 = wxString_in_helper(obj1);
17065 if (arg2 == NULL) SWIG_fail;
17066 temp2 = true;
17067 }
17068 {
17069 PyThreadState* __tstate = wxPyBeginAllowThreads();
17070 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17071 wxPyEndAllowThreads(__tstate);
17072 if (PyErr_Occurred()) SWIG_fail;
17073 }
17074 resultobj = SWIG_From_int(static_cast< int >(result));
17075 {
17076 if (temp2)
17077 delete arg2;
17078 }
17079 return resultobj;
17080 fail:
17081 {
17082 if (temp2)
17083 delete arg2;
17084 }
17085 return NULL;
17086 }
17087
17088
17089 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17090 PyObject *resultobj = 0;
17091 wxImage *arg1 = (wxImage *) 0 ;
17092 wxString *arg2 = 0 ;
17093 bool result;
17094 void *argp1 = 0 ;
17095 int res1 = 0 ;
17096 bool temp2 = false ;
17097 PyObject * obj0 = 0 ;
17098 PyObject * obj1 = 0 ;
17099 char * kwnames[] = {
17100 (char *) "self",(char *) "name", NULL
17101 };
17102
17103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17105 if (!SWIG_IsOK(res1)) {
17106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17107 }
17108 arg1 = reinterpret_cast< wxImage * >(argp1);
17109 {
17110 arg2 = wxString_in_helper(obj1);
17111 if (arg2 == NULL) SWIG_fail;
17112 temp2 = true;
17113 }
17114 {
17115 PyThreadState* __tstate = wxPyBeginAllowThreads();
17116 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17117 wxPyEndAllowThreads(__tstate);
17118 if (PyErr_Occurred()) SWIG_fail;
17119 }
17120 {
17121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17122 }
17123 {
17124 if (temp2)
17125 delete arg2;
17126 }
17127 return resultobj;
17128 fail:
17129 {
17130 if (temp2)
17131 delete arg2;
17132 }
17133 return NULL;
17134 }
17135
17136
17137 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17138 PyObject *resultobj = 0;
17139 wxImage *arg1 = (wxImage *) 0 ;
17140 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17141 unsigned long result;
17142 void *argp1 = 0 ;
17143 int res1 = 0 ;
17144 unsigned long val2 ;
17145 int ecode2 = 0 ;
17146 PyObject * obj0 = 0 ;
17147 PyObject * obj1 = 0 ;
17148 char * kwnames[] = {
17149 (char *) "self",(char *) "stopafter", NULL
17150 };
17151
17152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17154 if (!SWIG_IsOK(res1)) {
17155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17156 }
17157 arg1 = reinterpret_cast< wxImage * >(argp1);
17158 if (obj1) {
17159 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17160 if (!SWIG_IsOK(ecode2)) {
17161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17162 }
17163 arg2 = static_cast< unsigned long >(val2);
17164 }
17165 {
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 result = (unsigned long)(arg1)->CountColours(arg2);
17168 wxPyEndAllowThreads(__tstate);
17169 if (PyErr_Occurred()) SWIG_fail;
17170 }
17171 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17172 return resultobj;
17173 fail:
17174 return NULL;
17175 }
17176
17177
17178 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17179 PyObject *resultobj = 0;
17180 wxImage *arg1 = (wxImage *) 0 ;
17181 wxImageHistogram *arg2 = 0 ;
17182 unsigned long result;
17183 void *argp1 = 0 ;
17184 int res1 = 0 ;
17185 void *argp2 = 0 ;
17186 int res2 = 0 ;
17187 PyObject * obj0 = 0 ;
17188 PyObject * obj1 = 0 ;
17189 char * kwnames[] = {
17190 (char *) "self",(char *) "h", NULL
17191 };
17192
17193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17195 if (!SWIG_IsOK(res1)) {
17196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17197 }
17198 arg1 = reinterpret_cast< wxImage * >(argp1);
17199 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17200 if (!SWIG_IsOK(res2)) {
17201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17202 }
17203 if (!argp2) {
17204 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17205 }
17206 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17207 {
17208 PyThreadState* __tstate = wxPyBeginAllowThreads();
17209 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17214 return resultobj;
17215 fail:
17216 return NULL;
17217 }
17218
17219
17220 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17221 PyObject *resultobj = 0;
17222 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17223 void *argp1 = 0 ;
17224 int res1 = 0 ;
17225 PyObject * obj0 = 0 ;
17226 char * kwnames[] = {
17227 (char *) "handler", NULL
17228 };
17229
17230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17232 if (!SWIG_IsOK(res1)) {
17233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17234 }
17235 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17236 {
17237 PyThreadState* __tstate = wxPyBeginAllowThreads();
17238 wxImage::AddHandler(arg1);
17239 wxPyEndAllowThreads(__tstate);
17240 if (PyErr_Occurred()) SWIG_fail;
17241 }
17242 resultobj = SWIG_Py_Void();
17243 return resultobj;
17244 fail:
17245 return NULL;
17246 }
17247
17248
17249 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17250 PyObject *resultobj = 0;
17251 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17252 void *argp1 = 0 ;
17253 int res1 = 0 ;
17254 PyObject * obj0 = 0 ;
17255 char * kwnames[] = {
17256 (char *) "handler", NULL
17257 };
17258
17259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17261 if (!SWIG_IsOK(res1)) {
17262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17263 }
17264 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17265 {
17266 PyThreadState* __tstate = wxPyBeginAllowThreads();
17267 wxImage::InsertHandler(arg1);
17268 wxPyEndAllowThreads(__tstate);
17269 if (PyErr_Occurred()) SWIG_fail;
17270 }
17271 resultobj = SWIG_Py_Void();
17272 return resultobj;
17273 fail:
17274 return NULL;
17275 }
17276
17277
17278 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17279 PyObject *resultobj = 0;
17280 wxString *arg1 = 0 ;
17281 bool result;
17282 bool temp1 = false ;
17283 PyObject * obj0 = 0 ;
17284 char * kwnames[] = {
17285 (char *) "name", NULL
17286 };
17287
17288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17289 {
17290 arg1 = wxString_in_helper(obj0);
17291 if (arg1 == NULL) SWIG_fail;
17292 temp1 = true;
17293 }
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 {
17301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17302 }
17303 {
17304 if (temp1)
17305 delete arg1;
17306 }
17307 return resultobj;
17308 fail:
17309 {
17310 if (temp1)
17311 delete arg1;
17312 }
17313 return NULL;
17314 }
17315
17316
17317 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17318 PyObject *resultobj = 0;
17319 PyObject *result = 0 ;
17320
17321 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17322 {
17323 PyThreadState* __tstate = wxPyBeginAllowThreads();
17324 result = (PyObject *)wxImage_GetHandlers();
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 resultobj = result;
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 PyObject *resultobj = 0;
17337 wxString result;
17338
17339 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17340 {
17341 PyThreadState* __tstate = wxPyBeginAllowThreads();
17342 result = wxImage::GetImageExtWildcard();
17343 wxPyEndAllowThreads(__tstate);
17344 if (PyErr_Occurred()) SWIG_fail;
17345 }
17346 {
17347 #if wxUSE_UNICODE
17348 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17349 #else
17350 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17351 #endif
17352 }
17353 return resultobj;
17354 fail:
17355 return NULL;
17356 }
17357
17358
17359 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17360 PyObject *resultobj = 0;
17361 wxImage *arg1 = (wxImage *) 0 ;
17362 int arg2 = (int) -1 ;
17363 wxBitmap result;
17364 void *argp1 = 0 ;
17365 int res1 = 0 ;
17366 int val2 ;
17367 int ecode2 = 0 ;
17368 PyObject * obj0 = 0 ;
17369 PyObject * obj1 = 0 ;
17370 char * kwnames[] = {
17371 (char *) "self",(char *) "depth", NULL
17372 };
17373
17374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17376 if (!SWIG_IsOK(res1)) {
17377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17378 }
17379 arg1 = reinterpret_cast< wxImage * >(argp1);
17380 if (obj1) {
17381 ecode2 = SWIG_AsVal_int(obj1, &val2);
17382 if (!SWIG_IsOK(ecode2)) {
17383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17384 }
17385 arg2 = static_cast< int >(val2);
17386 }
17387 {
17388 if (!wxPyCheckForApp()) SWIG_fail;
17389 PyThreadState* __tstate = wxPyBeginAllowThreads();
17390 result = wxImage_ConvertToBitmap(arg1,arg2);
17391 wxPyEndAllowThreads(__tstate);
17392 if (PyErr_Occurred()) SWIG_fail;
17393 }
17394 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj = 0;
17403 wxImage *arg1 = (wxImage *) 0 ;
17404 byte arg2 ;
17405 byte arg3 ;
17406 byte arg4 ;
17407 wxBitmap result;
17408 void *argp1 = 0 ;
17409 int res1 = 0 ;
17410 unsigned char val2 ;
17411 int ecode2 = 0 ;
17412 unsigned char val3 ;
17413 int ecode3 = 0 ;
17414 unsigned char val4 ;
17415 int ecode4 = 0 ;
17416 PyObject * obj0 = 0 ;
17417 PyObject * obj1 = 0 ;
17418 PyObject * obj2 = 0 ;
17419 PyObject * obj3 = 0 ;
17420 char * kwnames[] = {
17421 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17422 };
17423
17424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17426 if (!SWIG_IsOK(res1)) {
17427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17428 }
17429 arg1 = reinterpret_cast< wxImage * >(argp1);
17430 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17431 if (!SWIG_IsOK(ecode2)) {
17432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17433 }
17434 arg2 = static_cast< byte >(val2);
17435 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17436 if (!SWIG_IsOK(ecode3)) {
17437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17438 }
17439 arg3 = static_cast< byte >(val3);
17440 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17441 if (!SWIG_IsOK(ecode4)) {
17442 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17443 }
17444 arg4 = static_cast< byte >(val4);
17445 {
17446 if (!wxPyCheckForApp()) SWIG_fail;
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17460 PyObject *resultobj = 0;
17461 wxImage *arg1 = (wxImage *) 0 ;
17462 double arg2 ;
17463 void *argp1 = 0 ;
17464 int res1 = 0 ;
17465 double val2 ;
17466 int ecode2 = 0 ;
17467 PyObject * obj0 = 0 ;
17468 PyObject * obj1 = 0 ;
17469 char * kwnames[] = {
17470 (char *) "self",(char *) "angle", NULL
17471 };
17472
17473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17475 if (!SWIG_IsOK(res1)) {
17476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17477 }
17478 arg1 = reinterpret_cast< wxImage * >(argp1);
17479 ecode2 = SWIG_AsVal_double(obj1, &val2);
17480 if (!SWIG_IsOK(ecode2)) {
17481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17482 }
17483 arg2 = static_cast< double >(val2);
17484 {
17485 PyThreadState* __tstate = wxPyBeginAllowThreads();
17486 (arg1)->RotateHue(arg2);
17487 wxPyEndAllowThreads(__tstate);
17488 if (PyErr_Occurred()) SWIG_fail;
17489 }
17490 resultobj = SWIG_Py_Void();
17491 return resultobj;
17492 fail:
17493 return NULL;
17494 }
17495
17496
17497 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17498 PyObject *resultobj = 0;
17499 wxImage_RGBValue arg1 ;
17500 wxImage_HSVValue result;
17501 void *argp1 ;
17502 int res1 = 0 ;
17503 PyObject * obj0 = 0 ;
17504 char * kwnames[] = {
17505 (char *) "rgb", NULL
17506 };
17507
17508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17509 {
17510 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17511 if (!SWIG_IsOK(res1)) {
17512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17513 }
17514 if (!argp1) {
17515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17516 } else {
17517 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17518 arg1 = *temp;
17519 if (SWIG_IsNewObj(res1)) delete temp;
17520 }
17521 }
17522 {
17523 PyThreadState* __tstate = wxPyBeginAllowThreads();
17524 result = wxImage::RGBtoHSV(arg1);
17525 wxPyEndAllowThreads(__tstate);
17526 if (PyErr_Occurred()) SWIG_fail;
17527 }
17528 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17529 return resultobj;
17530 fail:
17531 return NULL;
17532 }
17533
17534
17535 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17536 PyObject *resultobj = 0;
17537 wxImage_HSVValue arg1 ;
17538 wxImage_RGBValue result;
17539 void *argp1 ;
17540 int res1 = 0 ;
17541 PyObject * obj0 = 0 ;
17542 char * kwnames[] = {
17543 (char *) "hsv", NULL
17544 };
17545
17546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17547 {
17548 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17549 if (!SWIG_IsOK(res1)) {
17550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17551 }
17552 if (!argp1) {
17553 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17554 } else {
17555 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17556 arg1 = *temp;
17557 if (SWIG_IsNewObj(res1)) delete temp;
17558 }
17559 }
17560 {
17561 PyThreadState* __tstate = wxPyBeginAllowThreads();
17562 result = wxImage::HSVtoRGB(arg1);
17563 wxPyEndAllowThreads(__tstate);
17564 if (PyErr_Occurred()) SWIG_fail;
17565 }
17566 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17567 return resultobj;
17568 fail:
17569 return NULL;
17570 }
17571
17572
17573 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 PyObject *obj;
17575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17576 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17577 return SWIG_Py_Void();
17578 }
17579
17580 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17581 return SWIG_Python_InitShadowInstance(args);
17582 }
17583
17584 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17585 PyObject *resultobj = 0;
17586 int arg1 ;
17587 int arg2 ;
17588 buffer arg3 ;
17589 int arg4 ;
17590 buffer arg5 = (buffer) NULL ;
17591 int arg6 = (int) 0 ;
17592 wxImage *result = 0 ;
17593 int val1 ;
17594 int ecode1 = 0 ;
17595 int val2 ;
17596 int ecode2 = 0 ;
17597 Py_ssize_t temp3 ;
17598 Py_ssize_t temp5 ;
17599 PyObject * obj0 = 0 ;
17600 PyObject * obj1 = 0 ;
17601 PyObject * obj2 = 0 ;
17602 PyObject * obj3 = 0 ;
17603 char * kwnames[] = {
17604 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17605 };
17606
17607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17608 ecode1 = SWIG_AsVal_int(obj0, &val1);
17609 if (!SWIG_IsOK(ecode1)) {
17610 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17611 }
17612 arg1 = static_cast< int >(val1);
17613 ecode2 = SWIG_AsVal_int(obj1, &val2);
17614 if (!SWIG_IsOK(ecode2)) {
17615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17616 }
17617 arg2 = static_cast< int >(val2);
17618 {
17619 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17620 arg4 = (int)temp3;
17621 }
17622 if (obj3) {
17623 {
17624 if (obj3 != Py_None) {
17625 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17626 arg6 = (int)temp5;
17627 }
17628 }
17629 }
17630 {
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17633 wxPyEndAllowThreads(__tstate);
17634 if (PyErr_Occurred()) SWIG_fail;
17635 }
17636 {
17637 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17638 }
17639 return resultobj;
17640 fail:
17641 return NULL;
17642 }
17643
17644
17645 SWIGINTERN int NullImage_set(PyObject *) {
17646 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17647 return 1;
17648 }
17649
17650
17651 SWIGINTERN PyObject *NullImage_get(void) {
17652 PyObject *pyobj = 0;
17653
17654 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17655 return pyobj;
17656 }
17657
17658
17659 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17660 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17661 return 1;
17662 }
17663
17664
17665 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17666 PyObject *pyobj = 0;
17667
17668 {
17669 #if wxUSE_UNICODE
17670 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17671 #else
17672 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17673 #endif
17674 }
17675 return pyobj;
17676 }
17677
17678
17679 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17680 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17681 return 1;
17682 }
17683
17684
17685 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17686 PyObject *pyobj = 0;
17687
17688 {
17689 #if wxUSE_UNICODE
17690 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17691 #else
17692 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17693 #endif
17694 }
17695 return pyobj;
17696 }
17697
17698
17699 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17700 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17701 return 1;
17702 }
17703
17704
17705 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17706 PyObject *pyobj = 0;
17707
17708 {
17709 #if wxUSE_UNICODE
17710 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17711 #else
17712 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17713 #endif
17714 }
17715 return pyobj;
17716 }
17717
17718
17719 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17720 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17721 return 1;
17722 }
17723
17724
17725 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17726 PyObject *pyobj = 0;
17727
17728 {
17729 #if wxUSE_UNICODE
17730 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17731 #else
17732 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17733 #endif
17734 }
17735 return pyobj;
17736 }
17737
17738
17739 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17740 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17741 return 1;
17742 }
17743
17744
17745 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17746 PyObject *pyobj = 0;
17747
17748 {
17749 #if wxUSE_UNICODE
17750 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17751 #else
17752 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17753 #endif
17754 }
17755 return pyobj;
17756 }
17757
17758
17759 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17760 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17761 return 1;
17762 }
17763
17764
17765 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17766 PyObject *pyobj = 0;
17767
17768 {
17769 #if wxUSE_UNICODE
17770 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17771 #else
17772 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17773 #endif
17774 }
17775 return pyobj;
17776 }
17777
17778
17779 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17780 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17781 return 1;
17782 }
17783
17784
17785 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17786 PyObject *pyobj = 0;
17787
17788 {
17789 #if wxUSE_UNICODE
17790 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17791 #else
17792 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17793 #endif
17794 }
17795 return pyobj;
17796 }
17797
17798
17799 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17800 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17801 return 1;
17802 }
17803
17804
17805 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17806 PyObject *pyobj = 0;
17807
17808 {
17809 #if wxUSE_UNICODE
17810 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17811 #else
17812 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17813 #endif
17814 }
17815 return pyobj;
17816 }
17817
17818
17819 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17820 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17821 return 1;
17822 }
17823
17824
17825 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17826 PyObject *pyobj = 0;
17827
17828 {
17829 #if wxUSE_UNICODE
17830 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17831 #else
17832 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17833 #endif
17834 }
17835 return pyobj;
17836 }
17837
17838
17839 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17840 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17841 return 1;
17842 }
17843
17844
17845 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17846 PyObject *pyobj = 0;
17847
17848 {
17849 #if wxUSE_UNICODE
17850 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17851 #else
17852 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17853 #endif
17854 }
17855 return pyobj;
17856 }
17857
17858
17859 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17860 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17861 return 1;
17862 }
17863
17864
17865 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17866 PyObject *pyobj = 0;
17867
17868 {
17869 #if wxUSE_UNICODE
17870 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17871 #else
17872 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17873 #endif
17874 }
17875 return pyobj;
17876 }
17877
17878
17879 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17880 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17881 return 1;
17882 }
17883
17884
17885 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17886 PyObject *pyobj = 0;
17887
17888 {
17889 #if wxUSE_UNICODE
17890 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17891 #else
17892 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17893 #endif
17894 }
17895 return pyobj;
17896 }
17897
17898
17899 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17900 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17901 return 1;
17902 }
17903
17904
17905 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17906 PyObject *pyobj = 0;
17907
17908 {
17909 #if wxUSE_UNICODE
17910 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17911 #else
17912 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17913 #endif
17914 }
17915 return pyobj;
17916 }
17917
17918
17919 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17920 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17921 return 1;
17922 }
17923
17924
17925 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17926 PyObject *pyobj = 0;
17927
17928 {
17929 #if wxUSE_UNICODE
17930 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17931 #else
17932 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17933 #endif
17934 }
17935 return pyobj;
17936 }
17937
17938
17939 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17940 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17941 return 1;
17942 }
17943
17944
17945 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17946 PyObject *pyobj = 0;
17947
17948 {
17949 #if wxUSE_UNICODE
17950 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17951 #else
17952 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17953 #endif
17954 }
17955 return pyobj;
17956 }
17957
17958
17959 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17960 PyObject *resultobj = 0;
17961 wxBMPHandler *result = 0 ;
17962
17963 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17964 {
17965 PyThreadState* __tstate = wxPyBeginAllowThreads();
17966 result = (wxBMPHandler *)new wxBMPHandler();
17967 wxPyEndAllowThreads(__tstate);
17968 if (PyErr_Occurred()) SWIG_fail;
17969 }
17970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17971 return resultobj;
17972 fail:
17973 return NULL;
17974 }
17975
17976
17977 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17978 PyObject *obj;
17979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17980 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17981 return SWIG_Py_Void();
17982 }
17983
17984 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17985 return SWIG_Python_InitShadowInstance(args);
17986 }
17987
17988 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17989 PyObject *resultobj = 0;
17990 wxICOHandler *result = 0 ;
17991
17992 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17993 {
17994 PyThreadState* __tstate = wxPyBeginAllowThreads();
17995 result = (wxICOHandler *)new wxICOHandler();
17996 wxPyEndAllowThreads(__tstate);
17997 if (PyErr_Occurred()) SWIG_fail;
17998 }
17999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18007 PyObject *obj;
18008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18009 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
18010 return SWIG_Py_Void();
18011 }
18012
18013 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18014 return SWIG_Python_InitShadowInstance(args);
18015 }
18016
18017 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18018 PyObject *resultobj = 0;
18019 wxCURHandler *result = 0 ;
18020
18021 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18022 {
18023 PyThreadState* __tstate = wxPyBeginAllowThreads();
18024 result = (wxCURHandler *)new wxCURHandler();
18025 wxPyEndAllowThreads(__tstate);
18026 if (PyErr_Occurred()) SWIG_fail;
18027 }
18028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18029 return resultobj;
18030 fail:
18031 return NULL;
18032 }
18033
18034
18035 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18036 PyObject *obj;
18037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18038 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18039 return SWIG_Py_Void();
18040 }
18041
18042 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18043 return SWIG_Python_InitShadowInstance(args);
18044 }
18045
18046 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18047 PyObject *resultobj = 0;
18048 wxANIHandler *result = 0 ;
18049
18050 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18051 {
18052 PyThreadState* __tstate = wxPyBeginAllowThreads();
18053 result = (wxANIHandler *)new wxANIHandler();
18054 wxPyEndAllowThreads(__tstate);
18055 if (PyErr_Occurred()) SWIG_fail;
18056 }
18057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18058 return resultobj;
18059 fail:
18060 return NULL;
18061 }
18062
18063
18064 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18065 PyObject *obj;
18066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18067 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18068 return SWIG_Py_Void();
18069 }
18070
18071 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18072 return SWIG_Python_InitShadowInstance(args);
18073 }
18074
18075 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18076 PyObject *resultobj = 0;
18077 wxPNGHandler *result = 0 ;
18078
18079 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18080 {
18081 PyThreadState* __tstate = wxPyBeginAllowThreads();
18082 result = (wxPNGHandler *)new wxPNGHandler();
18083 wxPyEndAllowThreads(__tstate);
18084 if (PyErr_Occurred()) SWIG_fail;
18085 }
18086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18087 return resultobj;
18088 fail:
18089 return NULL;
18090 }
18091
18092
18093 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18094 PyObject *obj;
18095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18096 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18097 return SWIG_Py_Void();
18098 }
18099
18100 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18101 return SWIG_Python_InitShadowInstance(args);
18102 }
18103
18104 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18105 PyObject *resultobj = 0;
18106 wxGIFHandler *result = 0 ;
18107
18108 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18109 {
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 result = (wxGIFHandler *)new wxGIFHandler();
18112 wxPyEndAllowThreads(__tstate);
18113 if (PyErr_Occurred()) SWIG_fail;
18114 }
18115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18116 return resultobj;
18117 fail:
18118 return NULL;
18119 }
18120
18121
18122 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18123 PyObject *obj;
18124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18125 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18126 return SWIG_Py_Void();
18127 }
18128
18129 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18130 return SWIG_Python_InitShadowInstance(args);
18131 }
18132
18133 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18134 PyObject *resultobj = 0;
18135 wxPCXHandler *result = 0 ;
18136
18137 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18138 {
18139 PyThreadState* __tstate = wxPyBeginAllowThreads();
18140 result = (wxPCXHandler *)new wxPCXHandler();
18141 wxPyEndAllowThreads(__tstate);
18142 if (PyErr_Occurred()) SWIG_fail;
18143 }
18144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18145 return resultobj;
18146 fail:
18147 return NULL;
18148 }
18149
18150
18151 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18152 PyObject *obj;
18153 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18154 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18155 return SWIG_Py_Void();
18156 }
18157
18158 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18159 return SWIG_Python_InitShadowInstance(args);
18160 }
18161
18162 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18163 PyObject *resultobj = 0;
18164 wxJPEGHandler *result = 0 ;
18165
18166 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18167 {
18168 PyThreadState* __tstate = wxPyBeginAllowThreads();
18169 result = (wxJPEGHandler *)new wxJPEGHandler();
18170 wxPyEndAllowThreads(__tstate);
18171 if (PyErr_Occurred()) SWIG_fail;
18172 }
18173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18174 return resultobj;
18175 fail:
18176 return NULL;
18177 }
18178
18179
18180 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18181 PyObject *obj;
18182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18183 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18184 return SWIG_Py_Void();
18185 }
18186
18187 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18188 return SWIG_Python_InitShadowInstance(args);
18189 }
18190
18191 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18192 PyObject *resultobj = 0;
18193 wxPNMHandler *result = 0 ;
18194
18195 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18196 {
18197 PyThreadState* __tstate = wxPyBeginAllowThreads();
18198 result = (wxPNMHandler *)new wxPNMHandler();
18199 wxPyEndAllowThreads(__tstate);
18200 if (PyErr_Occurred()) SWIG_fail;
18201 }
18202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18203 return resultobj;
18204 fail:
18205 return NULL;
18206 }
18207
18208
18209 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18210 PyObject *obj;
18211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18212 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18213 return SWIG_Py_Void();
18214 }
18215
18216 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18217 return SWIG_Python_InitShadowInstance(args);
18218 }
18219
18220 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18221 PyObject *resultobj = 0;
18222 wxXPMHandler *result = 0 ;
18223
18224 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18225 {
18226 PyThreadState* __tstate = wxPyBeginAllowThreads();
18227 result = (wxXPMHandler *)new wxXPMHandler();
18228 wxPyEndAllowThreads(__tstate);
18229 if (PyErr_Occurred()) SWIG_fail;
18230 }
18231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18232 return resultobj;
18233 fail:
18234 return NULL;
18235 }
18236
18237
18238 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18239 PyObject *obj;
18240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18241 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18242 return SWIG_Py_Void();
18243 }
18244
18245 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18246 return SWIG_Python_InitShadowInstance(args);
18247 }
18248
18249 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18250 PyObject *resultobj = 0;
18251 wxTIFFHandler *result = 0 ;
18252
18253 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 result = (wxTIFFHandler *)new wxTIFFHandler();
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18268 PyObject *obj;
18269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18270 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18271 return SWIG_Py_Void();
18272 }
18273
18274 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18275 return SWIG_Python_InitShadowInstance(args);
18276 }
18277
18278 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj = 0;
18280 wxImage *arg1 = 0 ;
18281 wxImage *arg2 = 0 ;
18282 int arg3 = (int) 236 ;
18283 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18284 bool result;
18285 void *argp1 = 0 ;
18286 int res1 = 0 ;
18287 void *argp2 = 0 ;
18288 int res2 = 0 ;
18289 int val3 ;
18290 int ecode3 = 0 ;
18291 int val4 ;
18292 int ecode4 = 0 ;
18293 PyObject * obj0 = 0 ;
18294 PyObject * obj1 = 0 ;
18295 PyObject * obj2 = 0 ;
18296 PyObject * obj3 = 0 ;
18297 char * kwnames[] = {
18298 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18299 };
18300
18301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18302 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18305 }
18306 if (!argp1) {
18307 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18308 }
18309 arg1 = reinterpret_cast< wxImage * >(argp1);
18310 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18311 if (!SWIG_IsOK(res2)) {
18312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18313 }
18314 if (!argp2) {
18315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18316 }
18317 arg2 = reinterpret_cast< wxImage * >(argp2);
18318 if (obj2) {
18319 ecode3 = SWIG_AsVal_int(obj2, &val3);
18320 if (!SWIG_IsOK(ecode3)) {
18321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18322 }
18323 arg3 = static_cast< int >(val3);
18324 }
18325 if (obj3) {
18326 ecode4 = SWIG_AsVal_int(obj3, &val4);
18327 if (!SWIG_IsOK(ecode4)) {
18328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18329 }
18330 arg4 = static_cast< int >(val4);
18331 }
18332 {
18333 PyThreadState* __tstate = wxPyBeginAllowThreads();
18334 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18335 wxPyEndAllowThreads(__tstate);
18336 if (PyErr_Occurred()) SWIG_fail;
18337 }
18338 {
18339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18340 }
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18348 PyObject *obj;
18349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18350 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18351 return SWIG_Py_Void();
18352 }
18353
18354 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18355 PyObject *resultobj = 0;
18356 wxEvtHandler *result = 0 ;
18357
18358 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18359 {
18360 PyThreadState* __tstate = wxPyBeginAllowThreads();
18361 result = (wxEvtHandler *)new wxEvtHandler();
18362 wxPyEndAllowThreads(__tstate);
18363 if (PyErr_Occurred()) SWIG_fail;
18364 }
18365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18366 return resultobj;
18367 fail:
18368 return NULL;
18369 }
18370
18371
18372 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18373 PyObject *resultobj = 0;
18374 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18375 wxEvtHandler *result = 0 ;
18376 void *argp1 = 0 ;
18377 int res1 = 0 ;
18378 PyObject *swig_obj[1] ;
18379
18380 if (!args) SWIG_fail;
18381 swig_obj[0] = args;
18382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18383 if (!SWIG_IsOK(res1)) {
18384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18385 }
18386 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18387 {
18388 PyThreadState* __tstate = wxPyBeginAllowThreads();
18389 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18390 wxPyEndAllowThreads(__tstate);
18391 if (PyErr_Occurred()) SWIG_fail;
18392 }
18393 {
18394 resultobj = wxPyMake_wxObject(result, 0);
18395 }
18396 return resultobj;
18397 fail:
18398 return NULL;
18399 }
18400
18401
18402 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18403 PyObject *resultobj = 0;
18404 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18405 wxEvtHandler *result = 0 ;
18406 void *argp1 = 0 ;
18407 int res1 = 0 ;
18408 PyObject *swig_obj[1] ;
18409
18410 if (!args) SWIG_fail;
18411 swig_obj[0] = args;
18412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18413 if (!SWIG_IsOK(res1)) {
18414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18415 }
18416 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18417 {
18418 PyThreadState* __tstate = wxPyBeginAllowThreads();
18419 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18420 wxPyEndAllowThreads(__tstate);
18421 if (PyErr_Occurred()) SWIG_fail;
18422 }
18423 {
18424 resultobj = wxPyMake_wxObject(result, 0);
18425 }
18426 return resultobj;
18427 fail:
18428 return NULL;
18429 }
18430
18431
18432 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18433 PyObject *resultobj = 0;
18434 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18435 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18436 void *argp1 = 0 ;
18437 int res1 = 0 ;
18438 void *argp2 = 0 ;
18439 int res2 = 0 ;
18440 PyObject * obj0 = 0 ;
18441 PyObject * obj1 = 0 ;
18442 char * kwnames[] = {
18443 (char *) "self",(char *) "handler", NULL
18444 };
18445
18446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18448 if (!SWIG_IsOK(res1)) {
18449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18450 }
18451 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18452 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18453 if (!SWIG_IsOK(res2)) {
18454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18455 }
18456 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18457 {
18458 PyThreadState* __tstate = wxPyBeginAllowThreads();
18459 (arg1)->SetNextHandler(arg2);
18460 wxPyEndAllowThreads(__tstate);
18461 if (PyErr_Occurred()) SWIG_fail;
18462 }
18463 resultobj = SWIG_Py_Void();
18464 return resultobj;
18465 fail:
18466 return NULL;
18467 }
18468
18469
18470 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18471 PyObject *resultobj = 0;
18472 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18473 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18474 void *argp1 = 0 ;
18475 int res1 = 0 ;
18476 void *argp2 = 0 ;
18477 int res2 = 0 ;
18478 PyObject * obj0 = 0 ;
18479 PyObject * obj1 = 0 ;
18480 char * kwnames[] = {
18481 (char *) "self",(char *) "handler", NULL
18482 };
18483
18484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18486 if (!SWIG_IsOK(res1)) {
18487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18488 }
18489 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18490 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18491 if (!SWIG_IsOK(res2)) {
18492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18493 }
18494 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18495 {
18496 PyThreadState* __tstate = wxPyBeginAllowThreads();
18497 (arg1)->SetPreviousHandler(arg2);
18498 wxPyEndAllowThreads(__tstate);
18499 if (PyErr_Occurred()) SWIG_fail;
18500 }
18501 resultobj = SWIG_Py_Void();
18502 return resultobj;
18503 fail:
18504 return NULL;
18505 }
18506
18507
18508 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18509 PyObject *resultobj = 0;
18510 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18511 bool result;
18512 void *argp1 = 0 ;
18513 int res1 = 0 ;
18514 PyObject *swig_obj[1] ;
18515
18516 if (!args) SWIG_fail;
18517 swig_obj[0] = args;
18518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18519 if (!SWIG_IsOK(res1)) {
18520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18521 }
18522 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18523 {
18524 PyThreadState* __tstate = wxPyBeginAllowThreads();
18525 result = (bool)(arg1)->GetEvtHandlerEnabled();
18526 wxPyEndAllowThreads(__tstate);
18527 if (PyErr_Occurred()) SWIG_fail;
18528 }
18529 {
18530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18531 }
18532 return resultobj;
18533 fail:
18534 return NULL;
18535 }
18536
18537
18538 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18539 PyObject *resultobj = 0;
18540 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18541 bool arg2 ;
18542 void *argp1 = 0 ;
18543 int res1 = 0 ;
18544 bool val2 ;
18545 int ecode2 = 0 ;
18546 PyObject * obj0 = 0 ;
18547 PyObject * obj1 = 0 ;
18548 char * kwnames[] = {
18549 (char *) "self",(char *) "enabled", NULL
18550 };
18551
18552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18554 if (!SWIG_IsOK(res1)) {
18555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18556 }
18557 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18559 if (!SWIG_IsOK(ecode2)) {
18560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18561 }
18562 arg2 = static_cast< bool >(val2);
18563 {
18564 PyThreadState* __tstate = wxPyBeginAllowThreads();
18565 (arg1)->SetEvtHandlerEnabled(arg2);
18566 wxPyEndAllowThreads(__tstate);
18567 if (PyErr_Occurred()) SWIG_fail;
18568 }
18569 resultobj = SWIG_Py_Void();
18570 return resultobj;
18571 fail:
18572 return NULL;
18573 }
18574
18575
18576 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18577 PyObject *resultobj = 0;
18578 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18579 wxEvent *arg2 = 0 ;
18580 bool result;
18581 void *argp1 = 0 ;
18582 int res1 = 0 ;
18583 void *argp2 = 0 ;
18584 int res2 = 0 ;
18585 PyObject * obj0 = 0 ;
18586 PyObject * obj1 = 0 ;
18587 char * kwnames[] = {
18588 (char *) "self",(char *) "event", NULL
18589 };
18590
18591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18593 if (!SWIG_IsOK(res1)) {
18594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18595 }
18596 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18598 if (!SWIG_IsOK(res2)) {
18599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18600 }
18601 if (!argp2) {
18602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18603 }
18604 arg2 = reinterpret_cast< wxEvent * >(argp2);
18605 {
18606 PyThreadState* __tstate = wxPyBeginAllowThreads();
18607 result = (bool)(arg1)->ProcessEvent(*arg2);
18608 wxPyEndAllowThreads(__tstate);
18609 if (PyErr_Occurred()) SWIG_fail;
18610 }
18611 {
18612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18613 }
18614 return resultobj;
18615 fail:
18616 return NULL;
18617 }
18618
18619
18620 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18621 PyObject *resultobj = 0;
18622 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18623 wxEvent *arg2 = 0 ;
18624 void *argp1 = 0 ;
18625 int res1 = 0 ;
18626 void *argp2 = 0 ;
18627 int res2 = 0 ;
18628 PyObject * obj0 = 0 ;
18629 PyObject * obj1 = 0 ;
18630 char * kwnames[] = {
18631 (char *) "self",(char *) "event", NULL
18632 };
18633
18634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18636 if (!SWIG_IsOK(res1)) {
18637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18638 }
18639 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18640 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18641 if (!SWIG_IsOK(res2)) {
18642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18643 }
18644 if (!argp2) {
18645 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18646 }
18647 arg2 = reinterpret_cast< wxEvent * >(argp2);
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 (arg1)->AddPendingEvent(*arg2);
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 resultobj = SWIG_Py_Void();
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18662 PyObject *resultobj = 0;
18663 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18664 void *argp1 = 0 ;
18665 int res1 = 0 ;
18666 PyObject *swig_obj[1] ;
18667
18668 if (!args) SWIG_fail;
18669 swig_obj[0] = args;
18670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18671 if (!SWIG_IsOK(res1)) {
18672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18673 }
18674 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18675 {
18676 PyThreadState* __tstate = wxPyBeginAllowThreads();
18677 (arg1)->ProcessPendingEvents();
18678 wxPyEndAllowThreads(__tstate);
18679 if (PyErr_Occurred()) SWIG_fail;
18680 }
18681 resultobj = SWIG_Py_Void();
18682 return resultobj;
18683 fail:
18684 return NULL;
18685 }
18686
18687
18688 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18689 PyObject *resultobj = 0;
18690 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18691 bool arg2 = (bool) true ;
18692 void *argp1 = 0 ;
18693 int res1 = 0 ;
18694 bool val2 ;
18695 int ecode2 = 0 ;
18696 PyObject * obj0 = 0 ;
18697 PyObject * obj1 = 0 ;
18698 char * kwnames[] = {
18699 (char *) "self",(char *) "allow", NULL
18700 };
18701
18702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
18703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18704 if (!SWIG_IsOK(res1)) {
18705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18706 }
18707 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18708 if (obj1) {
18709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18710 if (!SWIG_IsOK(ecode2)) {
18711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
18712 }
18713 arg2 = static_cast< bool >(val2);
18714 }
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 (arg1)->AllowReentrance(arg2);
18718 wxPyEndAllowThreads(__tstate);
18719 if (PyErr_Occurred()) SWIG_fail;
18720 }
18721 resultobj = SWIG_Py_Void();
18722 return resultobj;
18723 fail:
18724 return NULL;
18725 }
18726
18727
18728 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18729 PyObject *resultobj = 0;
18730 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18731 bool result;
18732 void *argp1 = 0 ;
18733 int res1 = 0 ;
18734 PyObject *swig_obj[1] ;
18735
18736 if (!args) SWIG_fail;
18737 swig_obj[0] = args;
18738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18739 if (!SWIG_IsOK(res1)) {
18740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18741 }
18742 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18743 {
18744 PyThreadState* __tstate = wxPyBeginAllowThreads();
18745 result = (bool)(arg1)->IsReentranceAllowed();
18746 wxPyEndAllowThreads(__tstate);
18747 if (PyErr_Occurred()) SWIG_fail;
18748 }
18749 {
18750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18751 }
18752 return resultobj;
18753 fail:
18754 return NULL;
18755 }
18756
18757
18758 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18759 PyObject *resultobj = 0;
18760 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18761 bool result;
18762 void *argp1 = 0 ;
18763 int res1 = 0 ;
18764 PyObject *swig_obj[1] ;
18765
18766 if (!args) SWIG_fail;
18767 swig_obj[0] = args;
18768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18769 if (!SWIG_IsOK(res1)) {
18770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18771 }
18772 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (bool)(arg1)->IsEventHandlingInProgress();
18776 wxPyEndAllowThreads(__tstate);
18777 if (PyErr_Occurred()) SWIG_fail;
18778 }
18779 {
18780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18781 }
18782 return resultobj;
18783 fail:
18784 return NULL;
18785 }
18786
18787
18788 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18789 PyObject *resultobj = 0;
18790 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18791 int arg2 ;
18792 int arg3 ;
18793 int arg4 ;
18794 PyObject *arg5 = (PyObject *) 0 ;
18795 void *argp1 = 0 ;
18796 int res1 = 0 ;
18797 int val2 ;
18798 int ecode2 = 0 ;
18799 int val3 ;
18800 int ecode3 = 0 ;
18801 int val4 ;
18802 int ecode4 = 0 ;
18803 PyObject * obj0 = 0 ;
18804 PyObject * obj1 = 0 ;
18805 PyObject * obj2 = 0 ;
18806 PyObject * obj3 = 0 ;
18807 PyObject * obj4 = 0 ;
18808 char * kwnames[] = {
18809 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18810 };
18811
18812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18814 if (!SWIG_IsOK(res1)) {
18815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18816 }
18817 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18818 ecode2 = SWIG_AsVal_int(obj1, &val2);
18819 if (!SWIG_IsOK(ecode2)) {
18820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18821 }
18822 arg2 = static_cast< int >(val2);
18823 ecode3 = SWIG_AsVal_int(obj2, &val3);
18824 if (!SWIG_IsOK(ecode3)) {
18825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18826 }
18827 arg3 = static_cast< int >(val3);
18828 ecode4 = SWIG_AsVal_int(obj3, &val4);
18829 if (!SWIG_IsOK(ecode4)) {
18830 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18831 }
18832 arg4 = static_cast< int >(val4);
18833 arg5 = obj4;
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18837 wxPyEndAllowThreads(__tstate);
18838 if (PyErr_Occurred()) SWIG_fail;
18839 }
18840 resultobj = SWIG_Py_Void();
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18848 PyObject *resultobj = 0;
18849 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18850 int arg2 ;
18851 int arg3 = (int) -1 ;
18852 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18853 bool result;
18854 void *argp1 = 0 ;
18855 int res1 = 0 ;
18856 int val2 ;
18857 int ecode2 = 0 ;
18858 int val3 ;
18859 int ecode3 = 0 ;
18860 int val4 ;
18861 int ecode4 = 0 ;
18862 PyObject * obj0 = 0 ;
18863 PyObject * obj1 = 0 ;
18864 PyObject * obj2 = 0 ;
18865 PyObject * obj3 = 0 ;
18866 char * kwnames[] = {
18867 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18868 };
18869
18870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18872 if (!SWIG_IsOK(res1)) {
18873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18874 }
18875 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18876 ecode2 = SWIG_AsVal_int(obj1, &val2);
18877 if (!SWIG_IsOK(ecode2)) {
18878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18879 }
18880 arg2 = static_cast< int >(val2);
18881 if (obj2) {
18882 ecode3 = SWIG_AsVal_int(obj2, &val3);
18883 if (!SWIG_IsOK(ecode3)) {
18884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18885 }
18886 arg3 = static_cast< int >(val3);
18887 }
18888 if (obj3) {
18889 ecode4 = SWIG_AsVal_int(obj3, &val4);
18890 if (!SWIG_IsOK(ecode4)) {
18891 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18892 }
18893 arg4 = static_cast< wxEventType >(val4);
18894 }
18895 {
18896 PyThreadState* __tstate = wxPyBeginAllowThreads();
18897 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18898 wxPyEndAllowThreads(__tstate);
18899 if (PyErr_Occurred()) SWIG_fail;
18900 }
18901 {
18902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18903 }
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj = 0;
18912 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18913 PyObject *arg2 = (PyObject *) 0 ;
18914 bool arg3 = (bool) true ;
18915 void *argp1 = 0 ;
18916 int res1 = 0 ;
18917 bool val3 ;
18918 int ecode3 = 0 ;
18919 PyObject * obj0 = 0 ;
18920 PyObject * obj1 = 0 ;
18921 PyObject * obj2 = 0 ;
18922 char * kwnames[] = {
18923 (char *) "self",(char *) "_self",(char *) "incref", NULL
18924 };
18925
18926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18928 if (!SWIG_IsOK(res1)) {
18929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18930 }
18931 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18932 arg2 = obj1;
18933 if (obj2) {
18934 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18935 if (!SWIG_IsOK(ecode3)) {
18936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18937 }
18938 arg3 = static_cast< bool >(val3);
18939 }
18940 {
18941 PyThreadState* __tstate = wxPyBeginAllowThreads();
18942 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18943 wxPyEndAllowThreads(__tstate);
18944 if (PyErr_Occurred()) SWIG_fail;
18945 }
18946 resultobj = SWIG_Py_Void();
18947 return resultobj;
18948 fail:
18949 return NULL;
18950 }
18951
18952
18953 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18954 PyObject *obj;
18955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18956 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18957 return SWIG_Py_Void();
18958 }
18959
18960 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18961 return SWIG_Python_InitShadowInstance(args);
18962 }
18963
18964 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18965 PyObject *resultobj = 0;
18966 wxEventType result;
18967
18968 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18969 {
18970 PyThreadState* __tstate = wxPyBeginAllowThreads();
18971 result = (wxEventType)wxNewEventType();
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 resultobj = SWIG_From_int(static_cast< int >(result));
18976 return resultobj;
18977 fail:
18978 return NULL;
18979 }
18980
18981
18982 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18983 PyObject *resultobj = 0;
18984 wxEvent *arg1 = (wxEvent *) 0 ;
18985 void *argp1 = 0 ;
18986 int res1 = 0 ;
18987 PyObject *swig_obj[1] ;
18988
18989 if (!args) SWIG_fail;
18990 swig_obj[0] = args;
18991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18992 if (!SWIG_IsOK(res1)) {
18993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18994 }
18995 arg1 = reinterpret_cast< wxEvent * >(argp1);
18996 {
18997 PyThreadState* __tstate = wxPyBeginAllowThreads();
18998 delete arg1;
18999
19000 wxPyEndAllowThreads(__tstate);
19001 if (PyErr_Occurred()) SWIG_fail;
19002 }
19003 resultobj = SWIG_Py_Void();
19004 return resultobj;
19005 fail:
19006 return NULL;
19007 }
19008
19009
19010 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19011 PyObject *resultobj = 0;
19012 wxEvent *arg1 = (wxEvent *) 0 ;
19013 wxEventType arg2 ;
19014 void *argp1 = 0 ;
19015 int res1 = 0 ;
19016 int val2 ;
19017 int ecode2 = 0 ;
19018 PyObject * obj0 = 0 ;
19019 PyObject * obj1 = 0 ;
19020 char * kwnames[] = {
19021 (char *) "self",(char *) "typ", NULL
19022 };
19023
19024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
19025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19026 if (!SWIG_IsOK(res1)) {
19027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
19028 }
19029 arg1 = reinterpret_cast< wxEvent * >(argp1);
19030 ecode2 = SWIG_AsVal_int(obj1, &val2);
19031 if (!SWIG_IsOK(ecode2)) {
19032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
19033 }
19034 arg2 = static_cast< wxEventType >(val2);
19035 {
19036 PyThreadState* __tstate = wxPyBeginAllowThreads();
19037 (arg1)->SetEventType(arg2);
19038 wxPyEndAllowThreads(__tstate);
19039 if (PyErr_Occurred()) SWIG_fail;
19040 }
19041 resultobj = SWIG_Py_Void();
19042 return resultobj;
19043 fail:
19044 return NULL;
19045 }
19046
19047
19048 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19049 PyObject *resultobj = 0;
19050 wxEvent *arg1 = (wxEvent *) 0 ;
19051 wxEventType result;
19052 void *argp1 = 0 ;
19053 int res1 = 0 ;
19054 PyObject *swig_obj[1] ;
19055
19056 if (!args) SWIG_fail;
19057 swig_obj[0] = args;
19058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19059 if (!SWIG_IsOK(res1)) {
19060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
19061 }
19062 arg1 = reinterpret_cast< wxEvent * >(argp1);
19063 {
19064 PyThreadState* __tstate = wxPyBeginAllowThreads();
19065 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
19066 wxPyEndAllowThreads(__tstate);
19067 if (PyErr_Occurred()) SWIG_fail;
19068 }
19069 resultobj = SWIG_From_int(static_cast< int >(result));
19070 return resultobj;
19071 fail:
19072 return NULL;
19073 }
19074
19075
19076 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19077 PyObject *resultobj = 0;
19078 wxEvent *arg1 = (wxEvent *) 0 ;
19079 wxObject *result = 0 ;
19080 void *argp1 = 0 ;
19081 int res1 = 0 ;
19082 PyObject *swig_obj[1] ;
19083
19084 if (!args) SWIG_fail;
19085 swig_obj[0] = args;
19086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19087 if (!SWIG_IsOK(res1)) {
19088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
19089 }
19090 arg1 = reinterpret_cast< wxEvent * >(argp1);
19091 {
19092 PyThreadState* __tstate = wxPyBeginAllowThreads();
19093 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
19094 wxPyEndAllowThreads(__tstate);
19095 if (PyErr_Occurred()) SWIG_fail;
19096 }
19097 {
19098 resultobj = wxPyMake_wxObject(result, (bool)0);
19099 }
19100 return resultobj;
19101 fail:
19102 return NULL;
19103 }
19104
19105
19106 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj = 0;
19108 wxEvent *arg1 = (wxEvent *) 0 ;
19109 wxObject *arg2 = (wxObject *) 0 ;
19110 void *argp1 = 0 ;
19111 int res1 = 0 ;
19112 void *argp2 = 0 ;
19113 int res2 = 0 ;
19114 PyObject * obj0 = 0 ;
19115 PyObject * obj1 = 0 ;
19116 char * kwnames[] = {
19117 (char *) "self",(char *) "obj", NULL
19118 };
19119
19120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19122 if (!SWIG_IsOK(res1)) {
19123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19124 }
19125 arg1 = reinterpret_cast< wxEvent * >(argp1);
19126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19127 if (!SWIG_IsOK(res2)) {
19128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19129 }
19130 arg2 = reinterpret_cast< wxObject * >(argp2);
19131 {
19132 PyThreadState* __tstate = wxPyBeginAllowThreads();
19133 (arg1)->SetEventObject(arg2);
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 resultobj = SWIG_Py_Void();
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19145 PyObject *resultobj = 0;
19146 wxEvent *arg1 = (wxEvent *) 0 ;
19147 long result;
19148 void *argp1 = 0 ;
19149 int res1 = 0 ;
19150 PyObject *swig_obj[1] ;
19151
19152 if (!args) SWIG_fail;
19153 swig_obj[0] = args;
19154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19155 if (!SWIG_IsOK(res1)) {
19156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19157 }
19158 arg1 = reinterpret_cast< wxEvent * >(argp1);
19159 {
19160 PyThreadState* __tstate = wxPyBeginAllowThreads();
19161 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19162 wxPyEndAllowThreads(__tstate);
19163 if (PyErr_Occurred()) SWIG_fail;
19164 }
19165 resultobj = SWIG_From_long(static_cast< long >(result));
19166 return resultobj;
19167 fail:
19168 return NULL;
19169 }
19170
19171
19172 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19173 PyObject *resultobj = 0;
19174 wxEvent *arg1 = (wxEvent *) 0 ;
19175 long arg2 = (long) 0 ;
19176 void *argp1 = 0 ;
19177 int res1 = 0 ;
19178 long val2 ;
19179 int ecode2 = 0 ;
19180 PyObject * obj0 = 0 ;
19181 PyObject * obj1 = 0 ;
19182 char * kwnames[] = {
19183 (char *) "self",(char *) "ts", NULL
19184 };
19185
19186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19188 if (!SWIG_IsOK(res1)) {
19189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19190 }
19191 arg1 = reinterpret_cast< wxEvent * >(argp1);
19192 if (obj1) {
19193 ecode2 = SWIG_AsVal_long(obj1, &val2);
19194 if (!SWIG_IsOK(ecode2)) {
19195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19196 }
19197 arg2 = static_cast< long >(val2);
19198 }
19199 {
19200 PyThreadState* __tstate = wxPyBeginAllowThreads();
19201 (arg1)->SetTimestamp(arg2);
19202 wxPyEndAllowThreads(__tstate);
19203 if (PyErr_Occurred()) SWIG_fail;
19204 }
19205 resultobj = SWIG_Py_Void();
19206 return resultobj;
19207 fail:
19208 return NULL;
19209 }
19210
19211
19212 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19213 PyObject *resultobj = 0;
19214 wxEvent *arg1 = (wxEvent *) 0 ;
19215 int result;
19216 void *argp1 = 0 ;
19217 int res1 = 0 ;
19218 PyObject *swig_obj[1] ;
19219
19220 if (!args) SWIG_fail;
19221 swig_obj[0] = args;
19222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19223 if (!SWIG_IsOK(res1)) {
19224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19225 }
19226 arg1 = reinterpret_cast< wxEvent * >(argp1);
19227 {
19228 PyThreadState* __tstate = wxPyBeginAllowThreads();
19229 result = (int)((wxEvent const *)arg1)->GetId();
19230 wxPyEndAllowThreads(__tstate);
19231 if (PyErr_Occurred()) SWIG_fail;
19232 }
19233 resultobj = SWIG_From_int(static_cast< int >(result));
19234 return resultobj;
19235 fail:
19236 return NULL;
19237 }
19238
19239
19240 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19241 PyObject *resultobj = 0;
19242 wxEvent *arg1 = (wxEvent *) 0 ;
19243 int arg2 ;
19244 void *argp1 = 0 ;
19245 int res1 = 0 ;
19246 int val2 ;
19247 int ecode2 = 0 ;
19248 PyObject * obj0 = 0 ;
19249 PyObject * obj1 = 0 ;
19250 char * kwnames[] = {
19251 (char *) "self",(char *) "Id", NULL
19252 };
19253
19254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19256 if (!SWIG_IsOK(res1)) {
19257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19258 }
19259 arg1 = reinterpret_cast< wxEvent * >(argp1);
19260 ecode2 = SWIG_AsVal_int(obj1, &val2);
19261 if (!SWIG_IsOK(ecode2)) {
19262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19263 }
19264 arg2 = static_cast< int >(val2);
19265 {
19266 PyThreadState* __tstate = wxPyBeginAllowThreads();
19267 (arg1)->SetId(arg2);
19268 wxPyEndAllowThreads(__tstate);
19269 if (PyErr_Occurred()) SWIG_fail;
19270 }
19271 resultobj = SWIG_Py_Void();
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19279 PyObject *resultobj = 0;
19280 wxEvent *arg1 = (wxEvent *) 0 ;
19281 bool result;
19282 void *argp1 = 0 ;
19283 int res1 = 0 ;
19284 PyObject *swig_obj[1] ;
19285
19286 if (!args) SWIG_fail;
19287 swig_obj[0] = args;
19288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19289 if (!SWIG_IsOK(res1)) {
19290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19291 }
19292 arg1 = reinterpret_cast< wxEvent * >(argp1);
19293 {
19294 PyThreadState* __tstate = wxPyBeginAllowThreads();
19295 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19296 wxPyEndAllowThreads(__tstate);
19297 if (PyErr_Occurred()) SWIG_fail;
19298 }
19299 {
19300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19301 }
19302 return resultobj;
19303 fail:
19304 return NULL;
19305 }
19306
19307
19308 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19309 PyObject *resultobj = 0;
19310 wxEvent *arg1 = (wxEvent *) 0 ;
19311 bool arg2 = (bool) true ;
19312 void *argp1 = 0 ;
19313 int res1 = 0 ;
19314 bool val2 ;
19315 int ecode2 = 0 ;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char * kwnames[] = {
19319 (char *) "self",(char *) "skip", NULL
19320 };
19321
19322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19324 if (!SWIG_IsOK(res1)) {
19325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19326 }
19327 arg1 = reinterpret_cast< wxEvent * >(argp1);
19328 if (obj1) {
19329 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19330 if (!SWIG_IsOK(ecode2)) {
19331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19332 }
19333 arg2 = static_cast< bool >(val2);
19334 }
19335 {
19336 PyThreadState* __tstate = wxPyBeginAllowThreads();
19337 (arg1)->Skip(arg2);
19338 wxPyEndAllowThreads(__tstate);
19339 if (PyErr_Occurred()) SWIG_fail;
19340 }
19341 resultobj = SWIG_Py_Void();
19342 return resultobj;
19343 fail:
19344 return NULL;
19345 }
19346
19347
19348 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19349 PyObject *resultobj = 0;
19350 wxEvent *arg1 = (wxEvent *) 0 ;
19351 bool result;
19352 void *argp1 = 0 ;
19353 int res1 = 0 ;
19354 PyObject *swig_obj[1] ;
19355
19356 if (!args) SWIG_fail;
19357 swig_obj[0] = args;
19358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19359 if (!SWIG_IsOK(res1)) {
19360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19361 }
19362 arg1 = reinterpret_cast< wxEvent * >(argp1);
19363 {
19364 PyThreadState* __tstate = wxPyBeginAllowThreads();
19365 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19366 wxPyEndAllowThreads(__tstate);
19367 if (PyErr_Occurred()) SWIG_fail;
19368 }
19369 {
19370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19371 }
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19379 PyObject *resultobj = 0;
19380 wxEvent *arg1 = (wxEvent *) 0 ;
19381 bool result;
19382 void *argp1 = 0 ;
19383 int res1 = 0 ;
19384 PyObject *swig_obj[1] ;
19385
19386 if (!args) SWIG_fail;
19387 swig_obj[0] = args;
19388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19389 if (!SWIG_IsOK(res1)) {
19390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19391 }
19392 arg1 = reinterpret_cast< wxEvent * >(argp1);
19393 {
19394 PyThreadState* __tstate = wxPyBeginAllowThreads();
19395 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19396 wxPyEndAllowThreads(__tstate);
19397 if (PyErr_Occurred()) SWIG_fail;
19398 }
19399 {
19400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19401 }
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19409 PyObject *resultobj = 0;
19410 wxEvent *arg1 = (wxEvent *) 0 ;
19411 int result;
19412 void *argp1 = 0 ;
19413 int res1 = 0 ;
19414 PyObject *swig_obj[1] ;
19415
19416 if (!args) SWIG_fail;
19417 swig_obj[0] = args;
19418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19419 if (!SWIG_IsOK(res1)) {
19420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19421 }
19422 arg1 = reinterpret_cast< wxEvent * >(argp1);
19423 {
19424 PyThreadState* __tstate = wxPyBeginAllowThreads();
19425 result = (int)(arg1)->StopPropagation();
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 resultobj = SWIG_From_int(static_cast< int >(result));
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj = 0;
19438 wxEvent *arg1 = (wxEvent *) 0 ;
19439 int arg2 ;
19440 void *argp1 = 0 ;
19441 int res1 = 0 ;
19442 int val2 ;
19443 int ecode2 = 0 ;
19444 PyObject * obj0 = 0 ;
19445 PyObject * obj1 = 0 ;
19446 char * kwnames[] = {
19447 (char *) "self",(char *) "propagationLevel", NULL
19448 };
19449
19450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19452 if (!SWIG_IsOK(res1)) {
19453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19454 }
19455 arg1 = reinterpret_cast< wxEvent * >(argp1);
19456 ecode2 = SWIG_AsVal_int(obj1, &val2);
19457 if (!SWIG_IsOK(ecode2)) {
19458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19459 }
19460 arg2 = static_cast< int >(val2);
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 (arg1)->ResumePropagation(arg2);
19464 wxPyEndAllowThreads(__tstate);
19465 if (PyErr_Occurred()) SWIG_fail;
19466 }
19467 resultobj = SWIG_Py_Void();
19468 return resultobj;
19469 fail:
19470 return NULL;
19471 }
19472
19473
19474 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19475 PyObject *resultobj = 0;
19476 wxEvent *arg1 = (wxEvent *) 0 ;
19477 wxEvent *result = 0 ;
19478 void *argp1 = 0 ;
19479 int res1 = 0 ;
19480 PyObject *swig_obj[1] ;
19481
19482 if (!args) SWIG_fail;
19483 swig_obj[0] = args;
19484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19485 if (!SWIG_IsOK(res1)) {
19486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19487 }
19488 arg1 = reinterpret_cast< wxEvent * >(argp1);
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 result = (wxEvent *)(arg1)->Clone();
19492 wxPyEndAllowThreads(__tstate);
19493 if (PyErr_Occurred()) SWIG_fail;
19494 }
19495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19496 return resultobj;
19497 fail:
19498 return NULL;
19499 }
19500
19501
19502 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19503 PyObject *obj;
19504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19505 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19506 return SWIG_Py_Void();
19507 }
19508
19509 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19510 PyObject *resultobj = 0;
19511 wxEvent *arg1 = 0 ;
19512 wxPropagationDisabler *result = 0 ;
19513 void *argp1 = 0 ;
19514 int res1 = 0 ;
19515 PyObject * obj0 = 0 ;
19516 char * kwnames[] = {
19517 (char *) "event", NULL
19518 };
19519
19520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19521 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19522 if (!SWIG_IsOK(res1)) {
19523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19524 }
19525 if (!argp1) {
19526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19527 }
19528 arg1 = reinterpret_cast< wxEvent * >(argp1);
19529 {
19530 PyThreadState* __tstate = wxPyBeginAllowThreads();
19531 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19532 wxPyEndAllowThreads(__tstate);
19533 if (PyErr_Occurred()) SWIG_fail;
19534 }
19535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19536 return resultobj;
19537 fail:
19538 return NULL;
19539 }
19540
19541
19542 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19543 PyObject *resultobj = 0;
19544 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19545 void *argp1 = 0 ;
19546 int res1 = 0 ;
19547 PyObject *swig_obj[1] ;
19548
19549 if (!args) SWIG_fail;
19550 swig_obj[0] = args;
19551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19552 if (!SWIG_IsOK(res1)) {
19553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19554 }
19555 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19556 {
19557 PyThreadState* __tstate = wxPyBeginAllowThreads();
19558 delete arg1;
19559
19560 wxPyEndAllowThreads(__tstate);
19561 if (PyErr_Occurred()) SWIG_fail;
19562 }
19563 resultobj = SWIG_Py_Void();
19564 return resultobj;
19565 fail:
19566 return NULL;
19567 }
19568
19569
19570 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19571 PyObject *obj;
19572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19573 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19574 return SWIG_Py_Void();
19575 }
19576
19577 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19578 return SWIG_Python_InitShadowInstance(args);
19579 }
19580
19581 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj = 0;
19583 wxEvent *arg1 = 0 ;
19584 wxPropagateOnce *result = 0 ;
19585 void *argp1 = 0 ;
19586 int res1 = 0 ;
19587 PyObject * obj0 = 0 ;
19588 char * kwnames[] = {
19589 (char *) "event", NULL
19590 };
19591
19592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19593 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19594 if (!SWIG_IsOK(res1)) {
19595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19596 }
19597 if (!argp1) {
19598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19599 }
19600 arg1 = reinterpret_cast< wxEvent * >(argp1);
19601 {
19602 PyThreadState* __tstate = wxPyBeginAllowThreads();
19603 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19604 wxPyEndAllowThreads(__tstate);
19605 if (PyErr_Occurred()) SWIG_fail;
19606 }
19607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19608 return resultobj;
19609 fail:
19610 return NULL;
19611 }
19612
19613
19614 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19615 PyObject *resultobj = 0;
19616 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19617 void *argp1 = 0 ;
19618 int res1 = 0 ;
19619 PyObject *swig_obj[1] ;
19620
19621 if (!args) SWIG_fail;
19622 swig_obj[0] = args;
19623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19624 if (!SWIG_IsOK(res1)) {
19625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19626 }
19627 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 delete arg1;
19631
19632 wxPyEndAllowThreads(__tstate);
19633 if (PyErr_Occurred()) SWIG_fail;
19634 }
19635 resultobj = SWIG_Py_Void();
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19643 PyObject *obj;
19644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19645 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19646 return SWIG_Py_Void();
19647 }
19648
19649 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19650 return SWIG_Python_InitShadowInstance(args);
19651 }
19652
19653 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj = 0;
19655 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19656 int arg2 = (int) 0 ;
19657 wxCommandEvent *result = 0 ;
19658 int val1 ;
19659 int ecode1 = 0 ;
19660 int val2 ;
19661 int ecode2 = 0 ;
19662 PyObject * obj0 = 0 ;
19663 PyObject * obj1 = 0 ;
19664 char * kwnames[] = {
19665 (char *) "commandType",(char *) "winid", NULL
19666 };
19667
19668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19669 if (obj0) {
19670 ecode1 = SWIG_AsVal_int(obj0, &val1);
19671 if (!SWIG_IsOK(ecode1)) {
19672 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19673 }
19674 arg1 = static_cast< wxEventType >(val1);
19675 }
19676 if (obj1) {
19677 ecode2 = SWIG_AsVal_int(obj1, &val2);
19678 if (!SWIG_IsOK(ecode2)) {
19679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19680 }
19681 arg2 = static_cast< int >(val2);
19682 }
19683 {
19684 PyThreadState* __tstate = wxPyBeginAllowThreads();
19685 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19686 wxPyEndAllowThreads(__tstate);
19687 if (PyErr_Occurred()) SWIG_fail;
19688 }
19689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19690 return resultobj;
19691 fail:
19692 return NULL;
19693 }
19694
19695
19696 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19697 PyObject *resultobj = 0;
19698 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19699 int result;
19700 void *argp1 = 0 ;
19701 int res1 = 0 ;
19702 PyObject *swig_obj[1] ;
19703
19704 if (!args) SWIG_fail;
19705 swig_obj[0] = args;
19706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19707 if (!SWIG_IsOK(res1)) {
19708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19709 }
19710 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19711 {
19712 PyThreadState* __tstate = wxPyBeginAllowThreads();
19713 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19714 wxPyEndAllowThreads(__tstate);
19715 if (PyErr_Occurred()) SWIG_fail;
19716 }
19717 resultobj = SWIG_From_int(static_cast< int >(result));
19718 return resultobj;
19719 fail:
19720 return NULL;
19721 }
19722
19723
19724 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19725 PyObject *resultobj = 0;
19726 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19727 wxString *arg2 = 0 ;
19728 void *argp1 = 0 ;
19729 int res1 = 0 ;
19730 bool temp2 = false ;
19731 PyObject * obj0 = 0 ;
19732 PyObject * obj1 = 0 ;
19733 char * kwnames[] = {
19734 (char *) "self",(char *) "s", NULL
19735 };
19736
19737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19739 if (!SWIG_IsOK(res1)) {
19740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19741 }
19742 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19743 {
19744 arg2 = wxString_in_helper(obj1);
19745 if (arg2 == NULL) SWIG_fail;
19746 temp2 = true;
19747 }
19748 {
19749 PyThreadState* __tstate = wxPyBeginAllowThreads();
19750 (arg1)->SetString((wxString const &)*arg2);
19751 wxPyEndAllowThreads(__tstate);
19752 if (PyErr_Occurred()) SWIG_fail;
19753 }
19754 resultobj = SWIG_Py_Void();
19755 {
19756 if (temp2)
19757 delete arg2;
19758 }
19759 return resultobj;
19760 fail:
19761 {
19762 if (temp2)
19763 delete arg2;
19764 }
19765 return NULL;
19766 }
19767
19768
19769 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19770 PyObject *resultobj = 0;
19771 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19772 wxString result;
19773 void *argp1 = 0 ;
19774 int res1 = 0 ;
19775 PyObject *swig_obj[1] ;
19776
19777 if (!args) SWIG_fail;
19778 swig_obj[0] = args;
19779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19780 if (!SWIG_IsOK(res1)) {
19781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19782 }
19783 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = ((wxCommandEvent const *)arg1)->GetString();
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 {
19791 #if wxUSE_UNICODE
19792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19793 #else
19794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19795 #endif
19796 }
19797 return resultobj;
19798 fail:
19799 return NULL;
19800 }
19801
19802
19803 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19804 PyObject *resultobj = 0;
19805 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19806 bool result;
19807 void *argp1 = 0 ;
19808 int res1 = 0 ;
19809 PyObject *swig_obj[1] ;
19810
19811 if (!args) SWIG_fail;
19812 swig_obj[0] = args;
19813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19814 if (!SWIG_IsOK(res1)) {
19815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19816 }
19817 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19818 {
19819 PyThreadState* __tstate = wxPyBeginAllowThreads();
19820 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19821 wxPyEndAllowThreads(__tstate);
19822 if (PyErr_Occurred()) SWIG_fail;
19823 }
19824 {
19825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19826 }
19827 return resultobj;
19828 fail:
19829 return NULL;
19830 }
19831
19832
19833 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19834 PyObject *resultobj = 0;
19835 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19836 bool result;
19837 void *argp1 = 0 ;
19838 int res1 = 0 ;
19839 PyObject *swig_obj[1] ;
19840
19841 if (!args) SWIG_fail;
19842 swig_obj[0] = args;
19843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19844 if (!SWIG_IsOK(res1)) {
19845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19846 }
19847 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19851 wxPyEndAllowThreads(__tstate);
19852 if (PyErr_Occurred()) SWIG_fail;
19853 }
19854 {
19855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19856 }
19857 return resultobj;
19858 fail:
19859 return NULL;
19860 }
19861
19862
19863 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19864 PyObject *resultobj = 0;
19865 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19866 long arg2 ;
19867 void *argp1 = 0 ;
19868 int res1 = 0 ;
19869 long val2 ;
19870 int ecode2 = 0 ;
19871 PyObject * obj0 = 0 ;
19872 PyObject * obj1 = 0 ;
19873 char * kwnames[] = {
19874 (char *) "self",(char *) "extraLong", NULL
19875 };
19876
19877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19879 if (!SWIG_IsOK(res1)) {
19880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19881 }
19882 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19883 ecode2 = SWIG_AsVal_long(obj1, &val2);
19884 if (!SWIG_IsOK(ecode2)) {
19885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19886 }
19887 arg2 = static_cast< long >(val2);
19888 {
19889 PyThreadState* __tstate = wxPyBeginAllowThreads();
19890 (arg1)->SetExtraLong(arg2);
19891 wxPyEndAllowThreads(__tstate);
19892 if (PyErr_Occurred()) SWIG_fail;
19893 }
19894 resultobj = SWIG_Py_Void();
19895 return resultobj;
19896 fail:
19897 return NULL;
19898 }
19899
19900
19901 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19902 PyObject *resultobj = 0;
19903 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19904 long result;
19905 void *argp1 = 0 ;
19906 int res1 = 0 ;
19907 PyObject *swig_obj[1] ;
19908
19909 if (!args) SWIG_fail;
19910 swig_obj[0] = args;
19911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19912 if (!SWIG_IsOK(res1)) {
19913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19914 }
19915 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19916 {
19917 PyThreadState* __tstate = wxPyBeginAllowThreads();
19918 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19919 wxPyEndAllowThreads(__tstate);
19920 if (PyErr_Occurred()) SWIG_fail;
19921 }
19922 resultobj = SWIG_From_long(static_cast< long >(result));
19923 return resultobj;
19924 fail:
19925 return NULL;
19926 }
19927
19928
19929 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19930 PyObject *resultobj = 0;
19931 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19932 int arg2 ;
19933 void *argp1 = 0 ;
19934 int res1 = 0 ;
19935 int val2 ;
19936 int ecode2 = 0 ;
19937 PyObject * obj0 = 0 ;
19938 PyObject * obj1 = 0 ;
19939 char * kwnames[] = {
19940 (char *) "self",(char *) "i", NULL
19941 };
19942
19943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19945 if (!SWIG_IsOK(res1)) {
19946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19947 }
19948 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19949 ecode2 = SWIG_AsVal_int(obj1, &val2);
19950 if (!SWIG_IsOK(ecode2)) {
19951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19952 }
19953 arg2 = static_cast< int >(val2);
19954 {
19955 PyThreadState* __tstate = wxPyBeginAllowThreads();
19956 (arg1)->SetInt(arg2);
19957 wxPyEndAllowThreads(__tstate);
19958 if (PyErr_Occurred()) SWIG_fail;
19959 }
19960 resultobj = SWIG_Py_Void();
19961 return resultobj;
19962 fail:
19963 return NULL;
19964 }
19965
19966
19967 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19968 PyObject *resultobj = 0;
19969 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19970 int result;
19971 void *argp1 = 0 ;
19972 int res1 = 0 ;
19973 PyObject *swig_obj[1] ;
19974
19975 if (!args) SWIG_fail;
19976 swig_obj[0] = args;
19977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19978 if (!SWIG_IsOK(res1)) {
19979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19980 }
19981 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19982 {
19983 PyThreadState* __tstate = wxPyBeginAllowThreads();
19984 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19985 wxPyEndAllowThreads(__tstate);
19986 if (PyErr_Occurred()) SWIG_fail;
19987 }
19988 resultobj = SWIG_From_int(static_cast< int >(result));
19989 return resultobj;
19990 fail:
19991 return NULL;
19992 }
19993
19994
19995 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19996 PyObject *resultobj = 0;
19997 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19998 PyObject *result = 0 ;
19999 void *argp1 = 0 ;
20000 int res1 = 0 ;
20001 PyObject *swig_obj[1] ;
20002
20003 if (!args) SWIG_fail;
20004 swig_obj[0] = args;
20005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20006 if (!SWIG_IsOK(res1)) {
20007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20008 }
20009 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20010 {
20011 PyThreadState* __tstate = wxPyBeginAllowThreads();
20012 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
20013 wxPyEndAllowThreads(__tstate);
20014 if (PyErr_Occurred()) SWIG_fail;
20015 }
20016 resultobj = result;
20017 return resultobj;
20018 fail:
20019 return NULL;
20020 }
20021
20022
20023 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20024 PyObject *resultobj = 0;
20025 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20026 PyObject *arg2 = (PyObject *) 0 ;
20027 void *argp1 = 0 ;
20028 int res1 = 0 ;
20029 PyObject * obj0 = 0 ;
20030 PyObject * obj1 = 0 ;
20031 char * kwnames[] = {
20032 (char *) "self",(char *) "clientData", NULL
20033 };
20034
20035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
20036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20037 if (!SWIG_IsOK(res1)) {
20038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20039 }
20040 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20041 arg2 = obj1;
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 wxCommandEvent_SetClientData(arg1,arg2);
20045 wxPyEndAllowThreads(__tstate);
20046 if (PyErr_Occurred()) SWIG_fail;
20047 }
20048 resultobj = SWIG_Py_Void();
20049 return resultobj;
20050 fail:
20051 return NULL;
20052 }
20053
20054
20055 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20056 PyObject *resultobj = 0;
20057 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20058 wxEvent *result = 0 ;
20059 void *argp1 = 0 ;
20060 int res1 = 0 ;
20061 PyObject *swig_obj[1] ;
20062
20063 if (!args) SWIG_fail;
20064 swig_obj[0] = args;
20065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20066 if (!SWIG_IsOK(res1)) {
20067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
20068 }
20069 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20070 {
20071 PyThreadState* __tstate = wxPyBeginAllowThreads();
20072 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
20073 wxPyEndAllowThreads(__tstate);
20074 if (PyErr_Occurred()) SWIG_fail;
20075 }
20076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
20077 return resultobj;
20078 fail:
20079 return NULL;
20080 }
20081
20082
20083 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20084 PyObject *obj;
20085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20086 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
20087 return SWIG_Py_Void();
20088 }
20089
20090 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20091 return SWIG_Python_InitShadowInstance(args);
20092 }
20093
20094 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20095 PyObject *resultobj = 0;
20096 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20097 int arg2 = (int) 0 ;
20098 wxNotifyEvent *result = 0 ;
20099 int val1 ;
20100 int ecode1 = 0 ;
20101 int val2 ;
20102 int ecode2 = 0 ;
20103 PyObject * obj0 = 0 ;
20104 PyObject * obj1 = 0 ;
20105 char * kwnames[] = {
20106 (char *) "commandType",(char *) "winid", NULL
20107 };
20108
20109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20110 if (obj0) {
20111 ecode1 = SWIG_AsVal_int(obj0, &val1);
20112 if (!SWIG_IsOK(ecode1)) {
20113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20114 }
20115 arg1 = static_cast< wxEventType >(val1);
20116 }
20117 if (obj1) {
20118 ecode2 = SWIG_AsVal_int(obj1, &val2);
20119 if (!SWIG_IsOK(ecode2)) {
20120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20121 }
20122 arg2 = static_cast< int >(val2);
20123 }
20124 {
20125 PyThreadState* __tstate = wxPyBeginAllowThreads();
20126 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20127 wxPyEndAllowThreads(__tstate);
20128 if (PyErr_Occurred()) SWIG_fail;
20129 }
20130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20131 return resultobj;
20132 fail:
20133 return NULL;
20134 }
20135
20136
20137 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20138 PyObject *resultobj = 0;
20139 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20140 void *argp1 = 0 ;
20141 int res1 = 0 ;
20142 PyObject *swig_obj[1] ;
20143
20144 if (!args) SWIG_fail;
20145 swig_obj[0] = args;
20146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20147 if (!SWIG_IsOK(res1)) {
20148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20149 }
20150 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20151 {
20152 PyThreadState* __tstate = wxPyBeginAllowThreads();
20153 (arg1)->Veto();
20154 wxPyEndAllowThreads(__tstate);
20155 if (PyErr_Occurred()) SWIG_fail;
20156 }
20157 resultobj = SWIG_Py_Void();
20158 return resultobj;
20159 fail:
20160 return NULL;
20161 }
20162
20163
20164 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20165 PyObject *resultobj = 0;
20166 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20167 void *argp1 = 0 ;
20168 int res1 = 0 ;
20169 PyObject *swig_obj[1] ;
20170
20171 if (!args) SWIG_fail;
20172 swig_obj[0] = args;
20173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20174 if (!SWIG_IsOK(res1)) {
20175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20176 }
20177 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20178 {
20179 PyThreadState* __tstate = wxPyBeginAllowThreads();
20180 (arg1)->Allow();
20181 wxPyEndAllowThreads(__tstate);
20182 if (PyErr_Occurred()) SWIG_fail;
20183 }
20184 resultobj = SWIG_Py_Void();
20185 return resultobj;
20186 fail:
20187 return NULL;
20188 }
20189
20190
20191 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20192 PyObject *resultobj = 0;
20193 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20194 bool result;
20195 void *argp1 = 0 ;
20196 int res1 = 0 ;
20197 PyObject *swig_obj[1] ;
20198
20199 if (!args) SWIG_fail;
20200 swig_obj[0] = args;
20201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20202 if (!SWIG_IsOK(res1)) {
20203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20204 }
20205 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20206 {
20207 PyThreadState* __tstate = wxPyBeginAllowThreads();
20208 result = (bool)(arg1)->IsAllowed();
20209 wxPyEndAllowThreads(__tstate);
20210 if (PyErr_Occurred()) SWIG_fail;
20211 }
20212 {
20213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20214 }
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20222 PyObject *obj;
20223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20224 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20225 return SWIG_Py_Void();
20226 }
20227
20228 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20229 return SWIG_Python_InitShadowInstance(args);
20230 }
20231
20232 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20233 PyObject *resultobj = 0;
20234 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20235 int arg2 = (int) 0 ;
20236 int arg3 = (int) 0 ;
20237 int arg4 = (int) 0 ;
20238 wxScrollEvent *result = 0 ;
20239 int val1 ;
20240 int ecode1 = 0 ;
20241 int val2 ;
20242 int ecode2 = 0 ;
20243 int val3 ;
20244 int ecode3 = 0 ;
20245 int val4 ;
20246 int ecode4 = 0 ;
20247 PyObject * obj0 = 0 ;
20248 PyObject * obj1 = 0 ;
20249 PyObject * obj2 = 0 ;
20250 PyObject * obj3 = 0 ;
20251 char * kwnames[] = {
20252 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20253 };
20254
20255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20256 if (obj0) {
20257 ecode1 = SWIG_AsVal_int(obj0, &val1);
20258 if (!SWIG_IsOK(ecode1)) {
20259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20260 }
20261 arg1 = static_cast< wxEventType >(val1);
20262 }
20263 if (obj1) {
20264 ecode2 = SWIG_AsVal_int(obj1, &val2);
20265 if (!SWIG_IsOK(ecode2)) {
20266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20267 }
20268 arg2 = static_cast< int >(val2);
20269 }
20270 if (obj2) {
20271 ecode3 = SWIG_AsVal_int(obj2, &val3);
20272 if (!SWIG_IsOK(ecode3)) {
20273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20274 }
20275 arg3 = static_cast< int >(val3);
20276 }
20277 if (obj3) {
20278 ecode4 = SWIG_AsVal_int(obj3, &val4);
20279 if (!SWIG_IsOK(ecode4)) {
20280 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20281 }
20282 arg4 = static_cast< int >(val4);
20283 }
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20287 wxPyEndAllowThreads(__tstate);
20288 if (PyErr_Occurred()) SWIG_fail;
20289 }
20290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20298 PyObject *resultobj = 0;
20299 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20300 int result;
20301 void *argp1 = 0 ;
20302 int res1 = 0 ;
20303 PyObject *swig_obj[1] ;
20304
20305 if (!args) SWIG_fail;
20306 swig_obj[0] = args;
20307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20308 if (!SWIG_IsOK(res1)) {
20309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20310 }
20311 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20315 wxPyEndAllowThreads(__tstate);
20316 if (PyErr_Occurred()) SWIG_fail;
20317 }
20318 resultobj = SWIG_From_int(static_cast< int >(result));
20319 return resultobj;
20320 fail:
20321 return NULL;
20322 }
20323
20324
20325 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20326 PyObject *resultobj = 0;
20327 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20328 int result;
20329 void *argp1 = 0 ;
20330 int res1 = 0 ;
20331 PyObject *swig_obj[1] ;
20332
20333 if (!args) SWIG_fail;
20334 swig_obj[0] = args;
20335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20336 if (!SWIG_IsOK(res1)) {
20337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20338 }
20339 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20340 {
20341 PyThreadState* __tstate = wxPyBeginAllowThreads();
20342 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20343 wxPyEndAllowThreads(__tstate);
20344 if (PyErr_Occurred()) SWIG_fail;
20345 }
20346 resultobj = SWIG_From_int(static_cast< int >(result));
20347 return resultobj;
20348 fail:
20349 return NULL;
20350 }
20351
20352
20353 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20354 PyObject *resultobj = 0;
20355 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20356 int arg2 ;
20357 void *argp1 = 0 ;
20358 int res1 = 0 ;
20359 int val2 ;
20360 int ecode2 = 0 ;
20361 PyObject * obj0 = 0 ;
20362 PyObject * obj1 = 0 ;
20363 char * kwnames[] = {
20364 (char *) "self",(char *) "orient", NULL
20365 };
20366
20367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20369 if (!SWIG_IsOK(res1)) {
20370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20371 }
20372 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20373 ecode2 = SWIG_AsVal_int(obj1, &val2);
20374 if (!SWIG_IsOK(ecode2)) {
20375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20376 }
20377 arg2 = static_cast< int >(val2);
20378 {
20379 PyThreadState* __tstate = wxPyBeginAllowThreads();
20380 (arg1)->SetOrientation(arg2);
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 resultobj = SWIG_Py_Void();
20385 return resultobj;
20386 fail:
20387 return NULL;
20388 }
20389
20390
20391 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20392 PyObject *resultobj = 0;
20393 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20394 int arg2 ;
20395 void *argp1 = 0 ;
20396 int res1 = 0 ;
20397 int val2 ;
20398 int ecode2 = 0 ;
20399 PyObject * obj0 = 0 ;
20400 PyObject * obj1 = 0 ;
20401 char * kwnames[] = {
20402 (char *) "self",(char *) "pos", NULL
20403 };
20404
20405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20407 if (!SWIG_IsOK(res1)) {
20408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20409 }
20410 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20411 ecode2 = SWIG_AsVal_int(obj1, &val2);
20412 if (!SWIG_IsOK(ecode2)) {
20413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20414 }
20415 arg2 = static_cast< int >(val2);
20416 {
20417 PyThreadState* __tstate = wxPyBeginAllowThreads();
20418 (arg1)->SetPosition(arg2);
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 resultobj = SWIG_Py_Void();
20423 return resultobj;
20424 fail:
20425 return NULL;
20426 }
20427
20428
20429 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20430 PyObject *obj;
20431 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20432 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20433 return SWIG_Py_Void();
20434 }
20435
20436 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20437 return SWIG_Python_InitShadowInstance(args);
20438 }
20439
20440 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20441 PyObject *resultobj = 0;
20442 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20443 int arg2 = (int) 0 ;
20444 int arg3 = (int) 0 ;
20445 wxScrollWinEvent *result = 0 ;
20446 int val1 ;
20447 int ecode1 = 0 ;
20448 int val2 ;
20449 int ecode2 = 0 ;
20450 int val3 ;
20451 int ecode3 = 0 ;
20452 PyObject * obj0 = 0 ;
20453 PyObject * obj1 = 0 ;
20454 PyObject * obj2 = 0 ;
20455 char * kwnames[] = {
20456 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20457 };
20458
20459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20460 if (obj0) {
20461 ecode1 = SWIG_AsVal_int(obj0, &val1);
20462 if (!SWIG_IsOK(ecode1)) {
20463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20464 }
20465 arg1 = static_cast< wxEventType >(val1);
20466 }
20467 if (obj1) {
20468 ecode2 = SWIG_AsVal_int(obj1, &val2);
20469 if (!SWIG_IsOK(ecode2)) {
20470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20471 }
20472 arg2 = static_cast< int >(val2);
20473 }
20474 if (obj2) {
20475 ecode3 = SWIG_AsVal_int(obj2, &val3);
20476 if (!SWIG_IsOK(ecode3)) {
20477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20478 }
20479 arg3 = static_cast< int >(val3);
20480 }
20481 {
20482 PyThreadState* __tstate = wxPyBeginAllowThreads();
20483 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20495 PyObject *resultobj = 0;
20496 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20497 int result;
20498 void *argp1 = 0 ;
20499 int res1 = 0 ;
20500 PyObject *swig_obj[1] ;
20501
20502 if (!args) SWIG_fail;
20503 swig_obj[0] = args;
20504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20505 if (!SWIG_IsOK(res1)) {
20506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20507 }
20508 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20512 wxPyEndAllowThreads(__tstate);
20513 if (PyErr_Occurred()) SWIG_fail;
20514 }
20515 resultobj = SWIG_From_int(static_cast< int >(result));
20516 return resultobj;
20517 fail:
20518 return NULL;
20519 }
20520
20521
20522 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20523 PyObject *resultobj = 0;
20524 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20525 int result;
20526 void *argp1 = 0 ;
20527 int res1 = 0 ;
20528 PyObject *swig_obj[1] ;
20529
20530 if (!args) SWIG_fail;
20531 swig_obj[0] = args;
20532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20533 if (!SWIG_IsOK(res1)) {
20534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20535 }
20536 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20537 {
20538 PyThreadState* __tstate = wxPyBeginAllowThreads();
20539 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20540 wxPyEndAllowThreads(__tstate);
20541 if (PyErr_Occurred()) SWIG_fail;
20542 }
20543 resultobj = SWIG_From_int(static_cast< int >(result));
20544 return resultobj;
20545 fail:
20546 return NULL;
20547 }
20548
20549
20550 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20551 PyObject *resultobj = 0;
20552 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20553 int arg2 ;
20554 void *argp1 = 0 ;
20555 int res1 = 0 ;
20556 int val2 ;
20557 int ecode2 = 0 ;
20558 PyObject * obj0 = 0 ;
20559 PyObject * obj1 = 0 ;
20560 char * kwnames[] = {
20561 (char *) "self",(char *) "orient", NULL
20562 };
20563
20564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20566 if (!SWIG_IsOK(res1)) {
20567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20568 }
20569 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20570 ecode2 = SWIG_AsVal_int(obj1, &val2);
20571 if (!SWIG_IsOK(ecode2)) {
20572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20573 }
20574 arg2 = static_cast< int >(val2);
20575 {
20576 PyThreadState* __tstate = wxPyBeginAllowThreads();
20577 (arg1)->SetOrientation(arg2);
20578 wxPyEndAllowThreads(__tstate);
20579 if (PyErr_Occurred()) SWIG_fail;
20580 }
20581 resultobj = SWIG_Py_Void();
20582 return resultobj;
20583 fail:
20584 return NULL;
20585 }
20586
20587
20588 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20589 PyObject *resultobj = 0;
20590 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20591 int arg2 ;
20592 void *argp1 = 0 ;
20593 int res1 = 0 ;
20594 int val2 ;
20595 int ecode2 = 0 ;
20596 PyObject * obj0 = 0 ;
20597 PyObject * obj1 = 0 ;
20598 char * kwnames[] = {
20599 (char *) "self",(char *) "pos", NULL
20600 };
20601
20602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20604 if (!SWIG_IsOK(res1)) {
20605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20606 }
20607 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20608 ecode2 = SWIG_AsVal_int(obj1, &val2);
20609 if (!SWIG_IsOK(ecode2)) {
20610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20611 }
20612 arg2 = static_cast< int >(val2);
20613 {
20614 PyThreadState* __tstate = wxPyBeginAllowThreads();
20615 (arg1)->SetPosition(arg2);
20616 wxPyEndAllowThreads(__tstate);
20617 if (PyErr_Occurred()) SWIG_fail;
20618 }
20619 resultobj = SWIG_Py_Void();
20620 return resultobj;
20621 fail:
20622 return NULL;
20623 }
20624
20625
20626 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20627 PyObject *obj;
20628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20629 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20630 return SWIG_Py_Void();
20631 }
20632
20633 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20634 return SWIG_Python_InitShadowInstance(args);
20635 }
20636
20637 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20638 PyObject *resultobj = 0;
20639 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20640 wxMouseEvent *result = 0 ;
20641 int val1 ;
20642 int ecode1 = 0 ;
20643 PyObject * obj0 = 0 ;
20644 char * kwnames[] = {
20645 (char *) "mouseType", NULL
20646 };
20647
20648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20649 if (obj0) {
20650 ecode1 = SWIG_AsVal_int(obj0, &val1);
20651 if (!SWIG_IsOK(ecode1)) {
20652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20653 }
20654 arg1 = static_cast< wxEventType >(val1);
20655 }
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20670 PyObject *resultobj = 0;
20671 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20672 bool result;
20673 void *argp1 = 0 ;
20674 int res1 = 0 ;
20675 PyObject *swig_obj[1] ;
20676
20677 if (!args) SWIG_fail;
20678 swig_obj[0] = args;
20679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20680 if (!SWIG_IsOK(res1)) {
20681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20682 }
20683 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20687 wxPyEndAllowThreads(__tstate);
20688 if (PyErr_Occurred()) SWIG_fail;
20689 }
20690 {
20691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20692 }
20693 return resultobj;
20694 fail:
20695 return NULL;
20696 }
20697
20698
20699 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20700 PyObject *resultobj = 0;
20701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20702 int arg2 = (int) wxMOUSE_BTN_ANY ;
20703 bool result;
20704 void *argp1 = 0 ;
20705 int res1 = 0 ;
20706 int val2 ;
20707 int ecode2 = 0 ;
20708 PyObject * obj0 = 0 ;
20709 PyObject * obj1 = 0 ;
20710 char * kwnames[] = {
20711 (char *) "self",(char *) "but", NULL
20712 };
20713
20714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20716 if (!SWIG_IsOK(res1)) {
20717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20718 }
20719 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20720 if (obj1) {
20721 ecode2 = SWIG_AsVal_int(obj1, &val2);
20722 if (!SWIG_IsOK(ecode2)) {
20723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20724 }
20725 arg2 = static_cast< int >(val2);
20726 }
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20730 wxPyEndAllowThreads(__tstate);
20731 if (PyErr_Occurred()) SWIG_fail;
20732 }
20733 {
20734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20735 }
20736 return resultobj;
20737 fail:
20738 return NULL;
20739 }
20740
20741
20742 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20743 PyObject *resultobj = 0;
20744 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20745 int arg2 = (int) wxMOUSE_BTN_ANY ;
20746 bool result;
20747 void *argp1 = 0 ;
20748 int res1 = 0 ;
20749 int val2 ;
20750 int ecode2 = 0 ;
20751 PyObject * obj0 = 0 ;
20752 PyObject * obj1 = 0 ;
20753 char * kwnames[] = {
20754 (char *) "self",(char *) "but", NULL
20755 };
20756
20757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20759 if (!SWIG_IsOK(res1)) {
20760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20761 }
20762 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20763 if (obj1) {
20764 ecode2 = SWIG_AsVal_int(obj1, &val2);
20765 if (!SWIG_IsOK(ecode2)) {
20766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20767 }
20768 arg2 = static_cast< int >(val2);
20769 }
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 {
20777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20778 }
20779 return resultobj;
20780 fail:
20781 return NULL;
20782 }
20783
20784
20785 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20786 PyObject *resultobj = 0;
20787 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20788 int arg2 = (int) wxMOUSE_BTN_ANY ;
20789 bool result;
20790 void *argp1 = 0 ;
20791 int res1 = 0 ;
20792 int val2 ;
20793 int ecode2 = 0 ;
20794 PyObject * obj0 = 0 ;
20795 PyObject * obj1 = 0 ;
20796 char * kwnames[] = {
20797 (char *) "self",(char *) "but", NULL
20798 };
20799
20800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20802 if (!SWIG_IsOK(res1)) {
20803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20804 }
20805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20806 if (obj1) {
20807 ecode2 = SWIG_AsVal_int(obj1, &val2);
20808 if (!SWIG_IsOK(ecode2)) {
20809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20810 }
20811 arg2 = static_cast< int >(val2);
20812 }
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 {
20820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20821 }
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20829 PyObject *resultobj = 0;
20830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20831 int arg2 ;
20832 bool result;
20833 void *argp1 = 0 ;
20834 int res1 = 0 ;
20835 int val2 ;
20836 int ecode2 = 0 ;
20837 PyObject * obj0 = 0 ;
20838 PyObject * obj1 = 0 ;
20839 char * kwnames[] = {
20840 (char *) "self",(char *) "button", NULL
20841 };
20842
20843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20845 if (!SWIG_IsOK(res1)) {
20846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20847 }
20848 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20849 ecode2 = SWIG_AsVal_int(obj1, &val2);
20850 if (!SWIG_IsOK(ecode2)) {
20851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20852 }
20853 arg2 = static_cast< int >(val2);
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 {
20861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20862 }
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20870 PyObject *resultobj = 0;
20871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20872 int arg2 ;
20873 bool result;
20874 void *argp1 = 0 ;
20875 int res1 = 0 ;
20876 int val2 ;
20877 int ecode2 = 0 ;
20878 PyObject * obj0 = 0 ;
20879 PyObject * obj1 = 0 ;
20880 char * kwnames[] = {
20881 (char *) "self",(char *) "but", NULL
20882 };
20883
20884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20886 if (!SWIG_IsOK(res1)) {
20887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20888 }
20889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20890 ecode2 = SWIG_AsVal_int(obj1, &val2);
20891 if (!SWIG_IsOK(ecode2)) {
20892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20893 }
20894 arg2 = static_cast< int >(val2);
20895 {
20896 PyThreadState* __tstate = wxPyBeginAllowThreads();
20897 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 {
20902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20911 PyObject *resultobj = 0;
20912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20913 int result;
20914 void *argp1 = 0 ;
20915 int res1 = 0 ;
20916 PyObject *swig_obj[1] ;
20917
20918 if (!args) SWIG_fail;
20919 swig_obj[0] = args;
20920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20921 if (!SWIG_IsOK(res1)) {
20922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20923 }
20924 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20925 {
20926 PyThreadState* __tstate = wxPyBeginAllowThreads();
20927 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 resultobj = SWIG_From_int(static_cast< int >(result));
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20939 PyObject *resultobj = 0;
20940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20941 bool result;
20942 void *argp1 = 0 ;
20943 int res1 = 0 ;
20944 PyObject *swig_obj[1] ;
20945
20946 if (!args) SWIG_fail;
20947 swig_obj[0] = args;
20948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20949 if (!SWIG_IsOK(res1)) {
20950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20951 }
20952 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20953 {
20954 PyThreadState* __tstate = wxPyBeginAllowThreads();
20955 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20956 wxPyEndAllowThreads(__tstate);
20957 if (PyErr_Occurred()) SWIG_fail;
20958 }
20959 {
20960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20961 }
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20969 PyObject *resultobj = 0;
20970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20971 bool result;
20972 void *argp1 = 0 ;
20973 int res1 = 0 ;
20974 PyObject *swig_obj[1] ;
20975
20976 if (!args) SWIG_fail;
20977 swig_obj[0] = args;
20978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20979 if (!SWIG_IsOK(res1)) {
20980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20981 }
20982 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20983 {
20984 PyThreadState* __tstate = wxPyBeginAllowThreads();
20985 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 {
20990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20991 }
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20999 PyObject *resultobj = 0;
21000 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21001 bool result;
21002 void *argp1 = 0 ;
21003 int res1 = 0 ;
21004 PyObject *swig_obj[1] ;
21005
21006 if (!args) SWIG_fail;
21007 swig_obj[0] = args;
21008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21009 if (!SWIG_IsOK(res1)) {
21010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21011 }
21012 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 {
21020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21021 }
21022 return resultobj;
21023 fail:
21024 return NULL;
21025 }
21026
21027
21028 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21029 PyObject *resultobj = 0;
21030 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21031 bool result;
21032 void *argp1 = 0 ;
21033 int res1 = 0 ;
21034 PyObject *swig_obj[1] ;
21035
21036 if (!args) SWIG_fail;
21037 swig_obj[0] = args;
21038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21039 if (!SWIG_IsOK(res1)) {
21040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21041 }
21042 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21043 {
21044 PyThreadState* __tstate = wxPyBeginAllowThreads();
21045 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
21046 wxPyEndAllowThreads(__tstate);
21047 if (PyErr_Occurred()) SWIG_fail;
21048 }
21049 {
21050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21051 }
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21059 PyObject *resultobj = 0;
21060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21061 bool result;
21062 void *argp1 = 0 ;
21063 int res1 = 0 ;
21064 PyObject *swig_obj[1] ;
21065
21066 if (!args) SWIG_fail;
21067 swig_obj[0] = args;
21068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21069 if (!SWIG_IsOK(res1)) {
21070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21071 }
21072 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21073 {
21074 PyThreadState* __tstate = wxPyBeginAllowThreads();
21075 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 {
21080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21081 }
21082 return resultobj;
21083 fail:
21084 return NULL;
21085 }
21086
21087
21088 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21089 PyObject *resultobj = 0;
21090 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21091 bool result;
21092 void *argp1 = 0 ;
21093 int res1 = 0 ;
21094 PyObject *swig_obj[1] ;
21095
21096 if (!args) SWIG_fail;
21097 swig_obj[0] = args;
21098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21099 if (!SWIG_IsOK(res1)) {
21100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21101 }
21102 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 {
21110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21111 }
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21119 PyObject *resultobj = 0;
21120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21121 bool result;
21122 void *argp1 = 0 ;
21123 int res1 = 0 ;
21124 PyObject *swig_obj[1] ;
21125
21126 if (!args) SWIG_fail;
21127 swig_obj[0] = args;
21128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21129 if (!SWIG_IsOK(res1)) {
21130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21131 }
21132 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 {
21140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21141 }
21142 return resultobj;
21143 fail:
21144 return NULL;
21145 }
21146
21147
21148 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21149 PyObject *resultobj = 0;
21150 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21151 bool result;
21152 void *argp1 = 0 ;
21153 int res1 = 0 ;
21154 PyObject *swig_obj[1] ;
21155
21156 if (!args) SWIG_fail;
21157 swig_obj[0] = args;
21158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21159 if (!SWIG_IsOK(res1)) {
21160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21161 }
21162 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21163 {
21164 PyThreadState* __tstate = wxPyBeginAllowThreads();
21165 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21166 wxPyEndAllowThreads(__tstate);
21167 if (PyErr_Occurred()) SWIG_fail;
21168 }
21169 {
21170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21171 }
21172 return resultobj;
21173 fail:
21174 return NULL;
21175 }
21176
21177
21178 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21179 PyObject *resultobj = 0;
21180 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21181 bool result;
21182 void *argp1 = 0 ;
21183 int res1 = 0 ;
21184 PyObject *swig_obj[1] ;
21185
21186 if (!args) SWIG_fail;
21187 swig_obj[0] = args;
21188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21189 if (!SWIG_IsOK(res1)) {
21190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21191 }
21192 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21193 {
21194 PyThreadState* __tstate = wxPyBeginAllowThreads();
21195 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21196 wxPyEndAllowThreads(__tstate);
21197 if (PyErr_Occurred()) SWIG_fail;
21198 }
21199 {
21200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21201 }
21202 return resultobj;
21203 fail:
21204 return NULL;
21205 }
21206
21207
21208 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21209 PyObject *resultobj = 0;
21210 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21211 bool result;
21212 void *argp1 = 0 ;
21213 int res1 = 0 ;
21214 PyObject *swig_obj[1] ;
21215
21216 if (!args) SWIG_fail;
21217 swig_obj[0] = args;
21218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21219 if (!SWIG_IsOK(res1)) {
21220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21221 }
21222 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21223 {
21224 PyThreadState* __tstate = wxPyBeginAllowThreads();
21225 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21226 wxPyEndAllowThreads(__tstate);
21227 if (PyErr_Occurred()) SWIG_fail;
21228 }
21229 {
21230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21231 }
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21239 PyObject *resultobj = 0;
21240 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21241 bool result;
21242 void *argp1 = 0 ;
21243 int res1 = 0 ;
21244 PyObject *swig_obj[1] ;
21245
21246 if (!args) SWIG_fail;
21247 swig_obj[0] = args;
21248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21249 if (!SWIG_IsOK(res1)) {
21250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21251 }
21252 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21253 {
21254 PyThreadState* __tstate = wxPyBeginAllowThreads();
21255 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 {
21260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21261 }
21262 return resultobj;
21263 fail:
21264 return NULL;
21265 }
21266
21267
21268 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21269 PyObject *resultobj = 0;
21270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21271 bool result;
21272 void *argp1 = 0 ;
21273 int res1 = 0 ;
21274 PyObject *swig_obj[1] ;
21275
21276 if (!args) SWIG_fail;
21277 swig_obj[0] = args;
21278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21279 if (!SWIG_IsOK(res1)) {
21280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21281 }
21282 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21283 {
21284 PyThreadState* __tstate = wxPyBeginAllowThreads();
21285 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21286 wxPyEndAllowThreads(__tstate);
21287 if (PyErr_Occurred()) SWIG_fail;
21288 }
21289 {
21290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21291 }
21292 return resultobj;
21293 fail:
21294 return NULL;
21295 }
21296
21297
21298 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21299 PyObject *resultobj = 0;
21300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21301 bool result;
21302 void *argp1 = 0 ;
21303 int res1 = 0 ;
21304 PyObject *swig_obj[1] ;
21305
21306 if (!args) SWIG_fail;
21307 swig_obj[0] = args;
21308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21309 if (!SWIG_IsOK(res1)) {
21310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21311 }
21312 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21313 {
21314 PyThreadState* __tstate = wxPyBeginAllowThreads();
21315 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21316 wxPyEndAllowThreads(__tstate);
21317 if (PyErr_Occurred()) SWIG_fail;
21318 }
21319 {
21320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21321 }
21322 return resultobj;
21323 fail:
21324 return NULL;
21325 }
21326
21327
21328 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21329 PyObject *resultobj = 0;
21330 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21331 bool result;
21332 void *argp1 = 0 ;
21333 int res1 = 0 ;
21334 PyObject *swig_obj[1] ;
21335
21336 if (!args) SWIG_fail;
21337 swig_obj[0] = args;
21338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21339 if (!SWIG_IsOK(res1)) {
21340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21341 }
21342 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21343 {
21344 PyThreadState* __tstate = wxPyBeginAllowThreads();
21345 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21346 wxPyEndAllowThreads(__tstate);
21347 if (PyErr_Occurred()) SWIG_fail;
21348 }
21349 {
21350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21351 }
21352 return resultobj;
21353 fail:
21354 return NULL;
21355 }
21356
21357
21358 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21359 PyObject *resultobj = 0;
21360 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21361 bool result;
21362 void *argp1 = 0 ;
21363 int res1 = 0 ;
21364 PyObject *swig_obj[1] ;
21365
21366 if (!args) SWIG_fail;
21367 swig_obj[0] = args;
21368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21369 if (!SWIG_IsOK(res1)) {
21370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21371 }
21372 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21373 {
21374 PyThreadState* __tstate = wxPyBeginAllowThreads();
21375 result = (bool)(arg1)->LeftIsDown();
21376 wxPyEndAllowThreads(__tstate);
21377 if (PyErr_Occurred()) SWIG_fail;
21378 }
21379 {
21380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21381 }
21382 return resultobj;
21383 fail:
21384 return NULL;
21385 }
21386
21387
21388 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21389 PyObject *resultobj = 0;
21390 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21391 bool result;
21392 void *argp1 = 0 ;
21393 int res1 = 0 ;
21394 PyObject *swig_obj[1] ;
21395
21396 if (!args) SWIG_fail;
21397 swig_obj[0] = args;
21398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21399 if (!SWIG_IsOK(res1)) {
21400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21401 }
21402 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21403 {
21404 PyThreadState* __tstate = wxPyBeginAllowThreads();
21405 result = (bool)(arg1)->MiddleIsDown();
21406 wxPyEndAllowThreads(__tstate);
21407 if (PyErr_Occurred()) SWIG_fail;
21408 }
21409 {
21410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21411 }
21412 return resultobj;
21413 fail:
21414 return NULL;
21415 }
21416
21417
21418 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21419 PyObject *resultobj = 0;
21420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21421 bool result;
21422 void *argp1 = 0 ;
21423 int res1 = 0 ;
21424 PyObject *swig_obj[1] ;
21425
21426 if (!args) SWIG_fail;
21427 swig_obj[0] = args;
21428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21429 if (!SWIG_IsOK(res1)) {
21430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21431 }
21432 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21433 {
21434 PyThreadState* __tstate = wxPyBeginAllowThreads();
21435 result = (bool)(arg1)->RightIsDown();
21436 wxPyEndAllowThreads(__tstate);
21437 if (PyErr_Occurred()) SWIG_fail;
21438 }
21439 {
21440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21441 }
21442 return resultobj;
21443 fail:
21444 return NULL;
21445 }
21446
21447
21448 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21449 PyObject *resultobj = 0;
21450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21451 bool result;
21452 void *argp1 = 0 ;
21453 int res1 = 0 ;
21454 PyObject *swig_obj[1] ;
21455
21456 if (!args) SWIG_fail;
21457 swig_obj[0] = args;
21458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21459 if (!SWIG_IsOK(res1)) {
21460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21461 }
21462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21463 {
21464 PyThreadState* __tstate = wxPyBeginAllowThreads();
21465 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 {
21470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21471 }
21472 return resultobj;
21473 fail:
21474 return NULL;
21475 }
21476
21477
21478 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21479 PyObject *resultobj = 0;
21480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21481 bool result;
21482 void *argp1 = 0 ;
21483 int res1 = 0 ;
21484 PyObject *swig_obj[1] ;
21485
21486 if (!args) SWIG_fail;
21487 swig_obj[0] = args;
21488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21489 if (!SWIG_IsOK(res1)) {
21490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21491 }
21492 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21493 {
21494 PyThreadState* __tstate = wxPyBeginAllowThreads();
21495 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21496 wxPyEndAllowThreads(__tstate);
21497 if (PyErr_Occurred()) SWIG_fail;
21498 }
21499 {
21500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21501 }
21502 return resultobj;
21503 fail:
21504 return NULL;
21505 }
21506
21507
21508 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21509 PyObject *resultobj = 0;
21510 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21511 bool result;
21512 void *argp1 = 0 ;
21513 int res1 = 0 ;
21514 PyObject *swig_obj[1] ;
21515
21516 if (!args) SWIG_fail;
21517 swig_obj[0] = args;
21518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21519 if (!SWIG_IsOK(res1)) {
21520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21521 }
21522 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21523 {
21524 PyThreadState* __tstate = wxPyBeginAllowThreads();
21525 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21526 wxPyEndAllowThreads(__tstate);
21527 if (PyErr_Occurred()) SWIG_fail;
21528 }
21529 {
21530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21531 }
21532 return resultobj;
21533 fail:
21534 return NULL;
21535 }
21536
21537
21538 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21539 PyObject *resultobj = 0;
21540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21541 bool result;
21542 void *argp1 = 0 ;
21543 int res1 = 0 ;
21544 PyObject *swig_obj[1] ;
21545
21546 if (!args) SWIG_fail;
21547 swig_obj[0] = args;
21548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21549 if (!SWIG_IsOK(res1)) {
21550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21551 }
21552 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21553 {
21554 PyThreadState* __tstate = wxPyBeginAllowThreads();
21555 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21556 wxPyEndAllowThreads(__tstate);
21557 if (PyErr_Occurred()) SWIG_fail;
21558 }
21559 {
21560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21561 }
21562 return resultobj;
21563 fail:
21564 return NULL;
21565 }
21566
21567
21568 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21569 PyObject *resultobj = 0;
21570 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21571 wxPoint result;
21572 void *argp1 = 0 ;
21573 int res1 = 0 ;
21574 PyObject *swig_obj[1] ;
21575
21576 if (!args) SWIG_fail;
21577 swig_obj[0] = args;
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_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21581 }
21582 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21583 {
21584 PyThreadState* __tstate = wxPyBeginAllowThreads();
21585 result = (arg1)->GetPosition();
21586 wxPyEndAllowThreads(__tstate);
21587 if (PyErr_Occurred()) SWIG_fail;
21588 }
21589 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21590 return resultobj;
21591 fail:
21592 return NULL;
21593 }
21594
21595
21596 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21597 PyObject *resultobj = 0;
21598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21599 long *arg2 = (long *) 0 ;
21600 long *arg3 = (long *) 0 ;
21601 void *argp1 = 0 ;
21602 int res1 = 0 ;
21603 long temp2 ;
21604 int res2 = SWIG_TMPOBJ ;
21605 long temp3 ;
21606 int res3 = SWIG_TMPOBJ ;
21607 PyObject *swig_obj[1] ;
21608
21609 arg2 = &temp2;
21610 arg3 = &temp3;
21611 if (!args) SWIG_fail;
21612 swig_obj[0] = args;
21613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21614 if (!SWIG_IsOK(res1)) {
21615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21616 }
21617 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21618 {
21619 PyThreadState* __tstate = wxPyBeginAllowThreads();
21620 (arg1)->GetPosition(arg2,arg3);
21621 wxPyEndAllowThreads(__tstate);
21622 if (PyErr_Occurred()) SWIG_fail;
21623 }
21624 resultobj = SWIG_Py_Void();
21625 if (SWIG_IsTmpObj(res2)) {
21626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21627 } else {
21628 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21630 }
21631 if (SWIG_IsTmpObj(res3)) {
21632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21633 } else {
21634 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21636 }
21637 return resultobj;
21638 fail:
21639 return NULL;
21640 }
21641
21642
21643 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21644 PyObject *resultobj = 0;
21645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21646 wxDC *arg2 = 0 ;
21647 wxPoint result;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 void *argp2 = 0 ;
21651 int res2 = 0 ;
21652 PyObject * obj0 = 0 ;
21653 PyObject * obj1 = 0 ;
21654 char * kwnames[] = {
21655 (char *) "self",(char *) "dc", NULL
21656 };
21657
21658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21660 if (!SWIG_IsOK(res1)) {
21661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21662 }
21663 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21664 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21665 if (!SWIG_IsOK(res2)) {
21666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21667 }
21668 if (!argp2) {
21669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21670 }
21671 arg2 = reinterpret_cast< wxDC * >(argp2);
21672 {
21673 PyThreadState* __tstate = wxPyBeginAllowThreads();
21674 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21675 wxPyEndAllowThreads(__tstate);
21676 if (PyErr_Occurred()) SWIG_fail;
21677 }
21678 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21679 return resultobj;
21680 fail:
21681 return NULL;
21682 }
21683
21684
21685 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21686 PyObject *resultobj = 0;
21687 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21688 int result;
21689 void *argp1 = 0 ;
21690 int res1 = 0 ;
21691 PyObject *swig_obj[1] ;
21692
21693 if (!args) SWIG_fail;
21694 swig_obj[0] = args;
21695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21696 if (!SWIG_IsOK(res1)) {
21697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21698 }
21699 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 result = (int)((wxMouseEvent const *)arg1)->GetX();
21703 wxPyEndAllowThreads(__tstate);
21704 if (PyErr_Occurred()) SWIG_fail;
21705 }
21706 resultobj = SWIG_From_int(static_cast< int >(result));
21707 return resultobj;
21708 fail:
21709 return NULL;
21710 }
21711
21712
21713 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21714 PyObject *resultobj = 0;
21715 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21716 int result;
21717 void *argp1 = 0 ;
21718 int res1 = 0 ;
21719 PyObject *swig_obj[1] ;
21720
21721 if (!args) SWIG_fail;
21722 swig_obj[0] = args;
21723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21724 if (!SWIG_IsOK(res1)) {
21725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21726 }
21727 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (int)((wxMouseEvent const *)arg1)->GetY();
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 resultobj = SWIG_From_int(static_cast< int >(result));
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *resultobj = 0;
21743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21744 int result;
21745 void *argp1 = 0 ;
21746 int res1 = 0 ;
21747 PyObject *swig_obj[1] ;
21748
21749 if (!args) SWIG_fail;
21750 swig_obj[0] = args;
21751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21752 if (!SWIG_IsOK(res1)) {
21753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21754 }
21755 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21756 {
21757 PyThreadState* __tstate = wxPyBeginAllowThreads();
21758 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21759 wxPyEndAllowThreads(__tstate);
21760 if (PyErr_Occurred()) SWIG_fail;
21761 }
21762 resultobj = SWIG_From_int(static_cast< int >(result));
21763 return resultobj;
21764 fail:
21765 return NULL;
21766 }
21767
21768
21769 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21770 PyObject *resultobj = 0;
21771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21772 int result;
21773 void *argp1 = 0 ;
21774 int res1 = 0 ;
21775 PyObject *swig_obj[1] ;
21776
21777 if (!args) SWIG_fail;
21778 swig_obj[0] = args;
21779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21780 if (!SWIG_IsOK(res1)) {
21781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21782 }
21783 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21784 {
21785 PyThreadState* __tstate = wxPyBeginAllowThreads();
21786 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21787 wxPyEndAllowThreads(__tstate);
21788 if (PyErr_Occurred()) SWIG_fail;
21789 }
21790 resultobj = SWIG_From_int(static_cast< int >(result));
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21798 PyObject *resultobj = 0;
21799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21800 int result;
21801 void *argp1 = 0 ;
21802 int res1 = 0 ;
21803 PyObject *swig_obj[1] ;
21804
21805 if (!args) SWIG_fail;
21806 swig_obj[0] = args;
21807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21808 if (!SWIG_IsOK(res1)) {
21809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21810 }
21811 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21812 {
21813 PyThreadState* __tstate = wxPyBeginAllowThreads();
21814 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21815 wxPyEndAllowThreads(__tstate);
21816 if (PyErr_Occurred()) SWIG_fail;
21817 }
21818 resultobj = SWIG_From_int(static_cast< int >(result));
21819 return resultobj;
21820 fail:
21821 return NULL;
21822 }
21823
21824
21825 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21826 PyObject *resultobj = 0;
21827 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21828 bool result;
21829 void *argp1 = 0 ;
21830 int res1 = 0 ;
21831 PyObject *swig_obj[1] ;
21832
21833 if (!args) SWIG_fail;
21834 swig_obj[0] = args;
21835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21836 if (!SWIG_IsOK(res1)) {
21837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21838 }
21839 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21840 {
21841 PyThreadState* __tstate = wxPyBeginAllowThreads();
21842 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21843 wxPyEndAllowThreads(__tstate);
21844 if (PyErr_Occurred()) SWIG_fail;
21845 }
21846 {
21847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21848 }
21849 return resultobj;
21850 fail:
21851 return NULL;
21852 }
21853
21854
21855 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21856 PyObject *resultobj = 0;
21857 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21858 int arg2 ;
21859 void *argp1 = 0 ;
21860 int res1 = 0 ;
21861 int val2 ;
21862 int ecode2 = 0 ;
21863 PyObject *swig_obj[2] ;
21864
21865 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21867 if (!SWIG_IsOK(res1)) {
21868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21869 }
21870 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21871 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21872 if (!SWIG_IsOK(ecode2)) {
21873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21874 }
21875 arg2 = static_cast< int >(val2);
21876 if (arg1) (arg1)->m_x = arg2;
21877
21878 resultobj = SWIG_Py_Void();
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21886 PyObject *resultobj = 0;
21887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21888 int result;
21889 void *argp1 = 0 ;
21890 int res1 = 0 ;
21891 PyObject *swig_obj[1] ;
21892
21893 if (!args) SWIG_fail;
21894 swig_obj[0] = args;
21895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21896 if (!SWIG_IsOK(res1)) {
21897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21898 }
21899 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21900 result = (int) ((arg1)->m_x);
21901 resultobj = SWIG_From_int(static_cast< int >(result));
21902 return resultobj;
21903 fail:
21904 return NULL;
21905 }
21906
21907
21908 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21909 PyObject *resultobj = 0;
21910 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21911 int arg2 ;
21912 void *argp1 = 0 ;
21913 int res1 = 0 ;
21914 int val2 ;
21915 int ecode2 = 0 ;
21916 PyObject *swig_obj[2] ;
21917
21918 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21920 if (!SWIG_IsOK(res1)) {
21921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21922 }
21923 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21924 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21925 if (!SWIG_IsOK(ecode2)) {
21926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21927 }
21928 arg2 = static_cast< int >(val2);
21929 if (arg1) (arg1)->m_y = arg2;
21930
21931 resultobj = SWIG_Py_Void();
21932 return resultobj;
21933 fail:
21934 return NULL;
21935 }
21936
21937
21938 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21939 PyObject *resultobj = 0;
21940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21941 int result;
21942 void *argp1 = 0 ;
21943 int res1 = 0 ;
21944 PyObject *swig_obj[1] ;
21945
21946 if (!args) SWIG_fail;
21947 swig_obj[0] = args;
21948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21949 if (!SWIG_IsOK(res1)) {
21950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21951 }
21952 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21953 result = (int) ((arg1)->m_y);
21954 resultobj = SWIG_From_int(static_cast< int >(result));
21955 return resultobj;
21956 fail:
21957 return NULL;
21958 }
21959
21960
21961 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21962 PyObject *resultobj = 0;
21963 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21964 bool arg2 ;
21965 void *argp1 = 0 ;
21966 int res1 = 0 ;
21967 bool val2 ;
21968 int ecode2 = 0 ;
21969 PyObject *swig_obj[2] ;
21970
21971 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21973 if (!SWIG_IsOK(res1)) {
21974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21975 }
21976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21977 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21978 if (!SWIG_IsOK(ecode2)) {
21979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21980 }
21981 arg2 = static_cast< bool >(val2);
21982 if (arg1) (arg1)->m_leftDown = arg2;
21983
21984 resultobj = SWIG_Py_Void();
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21992 PyObject *resultobj = 0;
21993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21994 bool result;
21995 void *argp1 = 0 ;
21996 int res1 = 0 ;
21997 PyObject *swig_obj[1] ;
21998
21999 if (!args) SWIG_fail;
22000 swig_obj[0] = args;
22001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22002 if (!SWIG_IsOK(res1)) {
22003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22004 }
22005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22006 result = (bool) ((arg1)->m_leftDown);
22007 {
22008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22009 }
22010 return resultobj;
22011 fail:
22012 return NULL;
22013 }
22014
22015
22016 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22017 PyObject *resultobj = 0;
22018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22019 bool arg2 ;
22020 void *argp1 = 0 ;
22021 int res1 = 0 ;
22022 bool val2 ;
22023 int ecode2 = 0 ;
22024 PyObject *swig_obj[2] ;
22025
22026 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
22027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22028 if (!SWIG_IsOK(res1)) {
22029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22030 }
22031 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22032 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22033 if (!SWIG_IsOK(ecode2)) {
22034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
22035 }
22036 arg2 = static_cast< bool >(val2);
22037 if (arg1) (arg1)->m_middleDown = arg2;
22038
22039 resultobj = SWIG_Py_Void();
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22047 PyObject *resultobj = 0;
22048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22049 bool result;
22050 void *argp1 = 0 ;
22051 int res1 = 0 ;
22052 PyObject *swig_obj[1] ;
22053
22054 if (!args) SWIG_fail;
22055 swig_obj[0] = args;
22056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22057 if (!SWIG_IsOK(res1)) {
22058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22059 }
22060 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22061 result = (bool) ((arg1)->m_middleDown);
22062 {
22063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22064 }
22065 return resultobj;
22066 fail:
22067 return NULL;
22068 }
22069
22070
22071 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22072 PyObject *resultobj = 0;
22073 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22074 bool arg2 ;
22075 void *argp1 = 0 ;
22076 int res1 = 0 ;
22077 bool val2 ;
22078 int ecode2 = 0 ;
22079 PyObject *swig_obj[2] ;
22080
22081 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
22082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22083 if (!SWIG_IsOK(res1)) {
22084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22085 }
22086 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22087 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22088 if (!SWIG_IsOK(ecode2)) {
22089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
22090 }
22091 arg2 = static_cast< bool >(val2);
22092 if (arg1) (arg1)->m_rightDown = arg2;
22093
22094 resultobj = SWIG_Py_Void();
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22102 PyObject *resultobj = 0;
22103 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22104 bool result;
22105 void *argp1 = 0 ;
22106 int res1 = 0 ;
22107 PyObject *swig_obj[1] ;
22108
22109 if (!args) SWIG_fail;
22110 swig_obj[0] = args;
22111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22112 if (!SWIG_IsOK(res1)) {
22113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22114 }
22115 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22116 result = (bool) ((arg1)->m_rightDown);
22117 {
22118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22119 }
22120 return resultobj;
22121 fail:
22122 return NULL;
22123 }
22124
22125
22126 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22127 PyObject *resultobj = 0;
22128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22129 bool arg2 ;
22130 void *argp1 = 0 ;
22131 int res1 = 0 ;
22132 bool val2 ;
22133 int ecode2 = 0 ;
22134 PyObject *swig_obj[2] ;
22135
22136 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22138 if (!SWIG_IsOK(res1)) {
22139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22140 }
22141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22142 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22143 if (!SWIG_IsOK(ecode2)) {
22144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22145 }
22146 arg2 = static_cast< bool >(val2);
22147 if (arg1) (arg1)->m_controlDown = arg2;
22148
22149 resultobj = SWIG_Py_Void();
22150 return resultobj;
22151 fail:
22152 return NULL;
22153 }
22154
22155
22156 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22157 PyObject *resultobj = 0;
22158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22159 bool result;
22160 void *argp1 = 0 ;
22161 int res1 = 0 ;
22162 PyObject *swig_obj[1] ;
22163
22164 if (!args) SWIG_fail;
22165 swig_obj[0] = args;
22166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22167 if (!SWIG_IsOK(res1)) {
22168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22169 }
22170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22171 result = (bool) ((arg1)->m_controlDown);
22172 {
22173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22174 }
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *resultobj = 0;
22183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22184 bool arg2 ;
22185 void *argp1 = 0 ;
22186 int res1 = 0 ;
22187 bool val2 ;
22188 int ecode2 = 0 ;
22189 PyObject *swig_obj[2] ;
22190
22191 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22193 if (!SWIG_IsOK(res1)) {
22194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22195 }
22196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22197 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22198 if (!SWIG_IsOK(ecode2)) {
22199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22200 }
22201 arg2 = static_cast< bool >(val2);
22202 if (arg1) (arg1)->m_shiftDown = arg2;
22203
22204 resultobj = SWIG_Py_Void();
22205 return resultobj;
22206 fail:
22207 return NULL;
22208 }
22209
22210
22211 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22212 PyObject *resultobj = 0;
22213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22214 bool result;
22215 void *argp1 = 0 ;
22216 int res1 = 0 ;
22217 PyObject *swig_obj[1] ;
22218
22219 if (!args) SWIG_fail;
22220 swig_obj[0] = args;
22221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22222 if (!SWIG_IsOK(res1)) {
22223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22224 }
22225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22226 result = (bool) ((arg1)->m_shiftDown);
22227 {
22228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22229 }
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22239 bool arg2 ;
22240 void *argp1 = 0 ;
22241 int res1 = 0 ;
22242 bool val2 ;
22243 int ecode2 = 0 ;
22244 PyObject *swig_obj[2] ;
22245
22246 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22248 if (!SWIG_IsOK(res1)) {
22249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22250 }
22251 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22252 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22253 if (!SWIG_IsOK(ecode2)) {
22254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22255 }
22256 arg2 = static_cast< bool >(val2);
22257 if (arg1) (arg1)->m_altDown = arg2;
22258
22259 resultobj = SWIG_Py_Void();
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22267 PyObject *resultobj = 0;
22268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22269 bool result;
22270 void *argp1 = 0 ;
22271 int res1 = 0 ;
22272 PyObject *swig_obj[1] ;
22273
22274 if (!args) SWIG_fail;
22275 swig_obj[0] = args;
22276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22277 if (!SWIG_IsOK(res1)) {
22278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22279 }
22280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22281 result = (bool) ((arg1)->m_altDown);
22282 {
22283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22284 }
22285 return resultobj;
22286 fail:
22287 return NULL;
22288 }
22289
22290
22291 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22292 PyObject *resultobj = 0;
22293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22294 bool arg2 ;
22295 void *argp1 = 0 ;
22296 int res1 = 0 ;
22297 bool val2 ;
22298 int ecode2 = 0 ;
22299 PyObject *swig_obj[2] ;
22300
22301 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22303 if (!SWIG_IsOK(res1)) {
22304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22305 }
22306 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22307 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22308 if (!SWIG_IsOK(ecode2)) {
22309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22310 }
22311 arg2 = static_cast< bool >(val2);
22312 if (arg1) (arg1)->m_metaDown = arg2;
22313
22314 resultobj = SWIG_Py_Void();
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22322 PyObject *resultobj = 0;
22323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22324 bool result;
22325 void *argp1 = 0 ;
22326 int res1 = 0 ;
22327 PyObject *swig_obj[1] ;
22328
22329 if (!args) SWIG_fail;
22330 swig_obj[0] = args;
22331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22332 if (!SWIG_IsOK(res1)) {
22333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22334 }
22335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22336 result = (bool) ((arg1)->m_metaDown);
22337 {
22338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22339 }
22340 return resultobj;
22341 fail:
22342 return NULL;
22343 }
22344
22345
22346 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22347 PyObject *resultobj = 0;
22348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22349 int arg2 ;
22350 void *argp1 = 0 ;
22351 int res1 = 0 ;
22352 int val2 ;
22353 int ecode2 = 0 ;
22354 PyObject *swig_obj[2] ;
22355
22356 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22358 if (!SWIG_IsOK(res1)) {
22359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22360 }
22361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22362 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22363 if (!SWIG_IsOK(ecode2)) {
22364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22365 }
22366 arg2 = static_cast< int >(val2);
22367 if (arg1) (arg1)->m_wheelRotation = arg2;
22368
22369 resultobj = SWIG_Py_Void();
22370 return resultobj;
22371 fail:
22372 return NULL;
22373 }
22374
22375
22376 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22377 PyObject *resultobj = 0;
22378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22379 int result;
22380 void *argp1 = 0 ;
22381 int res1 = 0 ;
22382 PyObject *swig_obj[1] ;
22383
22384 if (!args) SWIG_fail;
22385 swig_obj[0] = args;
22386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22387 if (!SWIG_IsOK(res1)) {
22388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22389 }
22390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22391 result = (int) ((arg1)->m_wheelRotation);
22392 resultobj = SWIG_From_int(static_cast< int >(result));
22393 return resultobj;
22394 fail:
22395 return NULL;
22396 }
22397
22398
22399 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22400 PyObject *resultobj = 0;
22401 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22402 int arg2 ;
22403 void *argp1 = 0 ;
22404 int res1 = 0 ;
22405 int val2 ;
22406 int ecode2 = 0 ;
22407 PyObject *swig_obj[2] ;
22408
22409 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22411 if (!SWIG_IsOK(res1)) {
22412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22413 }
22414 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22415 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22416 if (!SWIG_IsOK(ecode2)) {
22417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22418 }
22419 arg2 = static_cast< int >(val2);
22420 if (arg1) (arg1)->m_wheelDelta = arg2;
22421
22422 resultobj = SWIG_Py_Void();
22423 return resultobj;
22424 fail:
22425 return NULL;
22426 }
22427
22428
22429 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22430 PyObject *resultobj = 0;
22431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22432 int result;
22433 void *argp1 = 0 ;
22434 int res1 = 0 ;
22435 PyObject *swig_obj[1] ;
22436
22437 if (!args) SWIG_fail;
22438 swig_obj[0] = args;
22439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22440 if (!SWIG_IsOK(res1)) {
22441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22442 }
22443 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22444 result = (int) ((arg1)->m_wheelDelta);
22445 resultobj = SWIG_From_int(static_cast< int >(result));
22446 return resultobj;
22447 fail:
22448 return NULL;
22449 }
22450
22451
22452 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22453 PyObject *resultobj = 0;
22454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22455 int arg2 ;
22456 void *argp1 = 0 ;
22457 int res1 = 0 ;
22458 int val2 ;
22459 int ecode2 = 0 ;
22460 PyObject *swig_obj[2] ;
22461
22462 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22464 if (!SWIG_IsOK(res1)) {
22465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22466 }
22467 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22468 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22469 if (!SWIG_IsOK(ecode2)) {
22470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22471 }
22472 arg2 = static_cast< int >(val2);
22473 if (arg1) (arg1)->m_linesPerAction = arg2;
22474
22475 resultobj = SWIG_Py_Void();
22476 return resultobj;
22477 fail:
22478 return NULL;
22479 }
22480
22481
22482 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22483 PyObject *resultobj = 0;
22484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22485 int result;
22486 void *argp1 = 0 ;
22487 int res1 = 0 ;
22488 PyObject *swig_obj[1] ;
22489
22490 if (!args) SWIG_fail;
22491 swig_obj[0] = args;
22492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22493 if (!SWIG_IsOK(res1)) {
22494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22495 }
22496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22497 result = (int) ((arg1)->m_linesPerAction);
22498 resultobj = SWIG_From_int(static_cast< int >(result));
22499 return resultobj;
22500 fail:
22501 return NULL;
22502 }
22503
22504
22505 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22506 PyObject *obj;
22507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22508 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22509 return SWIG_Py_Void();
22510 }
22511
22512 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22513 return SWIG_Python_InitShadowInstance(args);
22514 }
22515
22516 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22517 PyObject *resultobj = 0;
22518 int arg1 = (int) 0 ;
22519 int arg2 = (int) 0 ;
22520 wxSetCursorEvent *result = 0 ;
22521 int val1 ;
22522 int ecode1 = 0 ;
22523 int val2 ;
22524 int ecode2 = 0 ;
22525 PyObject * obj0 = 0 ;
22526 PyObject * obj1 = 0 ;
22527 char * kwnames[] = {
22528 (char *) "x",(char *) "y", NULL
22529 };
22530
22531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22532 if (obj0) {
22533 ecode1 = SWIG_AsVal_int(obj0, &val1);
22534 if (!SWIG_IsOK(ecode1)) {
22535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22536 }
22537 arg1 = static_cast< int >(val1);
22538 }
22539 if (obj1) {
22540 ecode2 = SWIG_AsVal_int(obj1, &val2);
22541 if (!SWIG_IsOK(ecode2)) {
22542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22543 }
22544 arg2 = static_cast< int >(val2);
22545 }
22546 {
22547 PyThreadState* __tstate = wxPyBeginAllowThreads();
22548 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22549 wxPyEndAllowThreads(__tstate);
22550 if (PyErr_Occurred()) SWIG_fail;
22551 }
22552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22553 return resultobj;
22554 fail:
22555 return NULL;
22556 }
22557
22558
22559 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22560 PyObject *resultobj = 0;
22561 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22562 int result;
22563 void *argp1 = 0 ;
22564 int res1 = 0 ;
22565 PyObject *swig_obj[1] ;
22566
22567 if (!args) SWIG_fail;
22568 swig_obj[0] = args;
22569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22570 if (!SWIG_IsOK(res1)) {
22571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22572 }
22573 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22574 {
22575 PyThreadState* __tstate = wxPyBeginAllowThreads();
22576 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22577 wxPyEndAllowThreads(__tstate);
22578 if (PyErr_Occurred()) SWIG_fail;
22579 }
22580 resultobj = SWIG_From_int(static_cast< int >(result));
22581 return resultobj;
22582 fail:
22583 return NULL;
22584 }
22585
22586
22587 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22588 PyObject *resultobj = 0;
22589 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22590 int result;
22591 void *argp1 = 0 ;
22592 int res1 = 0 ;
22593 PyObject *swig_obj[1] ;
22594
22595 if (!args) SWIG_fail;
22596 swig_obj[0] = args;
22597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22598 if (!SWIG_IsOK(res1)) {
22599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22600 }
22601 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22605 wxPyEndAllowThreads(__tstate);
22606 if (PyErr_Occurred()) SWIG_fail;
22607 }
22608 resultobj = SWIG_From_int(static_cast< int >(result));
22609 return resultobj;
22610 fail:
22611 return NULL;
22612 }
22613
22614
22615 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22616 PyObject *resultobj = 0;
22617 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22618 wxCursor *arg2 = 0 ;
22619 void *argp1 = 0 ;
22620 int res1 = 0 ;
22621 void *argp2 = 0 ;
22622 int res2 = 0 ;
22623 PyObject * obj0 = 0 ;
22624 PyObject * obj1 = 0 ;
22625 char * kwnames[] = {
22626 (char *) "self",(char *) "cursor", NULL
22627 };
22628
22629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22631 if (!SWIG_IsOK(res1)) {
22632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22633 }
22634 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22635 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22636 if (!SWIG_IsOK(res2)) {
22637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22638 }
22639 if (!argp2) {
22640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22641 }
22642 arg2 = reinterpret_cast< wxCursor * >(argp2);
22643 {
22644 PyThreadState* __tstate = wxPyBeginAllowThreads();
22645 (arg1)->SetCursor((wxCursor const &)*arg2);
22646 wxPyEndAllowThreads(__tstate);
22647 if (PyErr_Occurred()) SWIG_fail;
22648 }
22649 resultobj = SWIG_Py_Void();
22650 return resultobj;
22651 fail:
22652 return NULL;
22653 }
22654
22655
22656 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22657 PyObject *resultobj = 0;
22658 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22659 wxCursor *result = 0 ;
22660 void *argp1 = 0 ;
22661 int res1 = 0 ;
22662 PyObject *swig_obj[1] ;
22663
22664 if (!args) SWIG_fail;
22665 swig_obj[0] = args;
22666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22667 if (!SWIG_IsOK(res1)) {
22668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22669 }
22670 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22671 {
22672 PyThreadState* __tstate = wxPyBeginAllowThreads();
22673 {
22674 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22675 result = (wxCursor *) &_result_ref;
22676 }
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 {
22681 wxCursor* resultptr = new wxCursor(*result);
22682 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22683 }
22684 return resultobj;
22685 fail:
22686 return NULL;
22687 }
22688
22689
22690 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22691 PyObject *resultobj = 0;
22692 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22693 bool result;
22694 void *argp1 = 0 ;
22695 int res1 = 0 ;
22696 PyObject *swig_obj[1] ;
22697
22698 if (!args) SWIG_fail;
22699 swig_obj[0] = args;
22700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22701 if (!SWIG_IsOK(res1)) {
22702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22703 }
22704 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22705 {
22706 PyThreadState* __tstate = wxPyBeginAllowThreads();
22707 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22708 wxPyEndAllowThreads(__tstate);
22709 if (PyErr_Occurred()) SWIG_fail;
22710 }
22711 {
22712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22713 }
22714 return resultobj;
22715 fail:
22716 return NULL;
22717 }
22718
22719
22720 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22721 PyObject *obj;
22722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22723 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22724 return SWIG_Py_Void();
22725 }
22726
22727 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22728 return SWIG_Python_InitShadowInstance(args);
22729 }
22730
22731 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22732 PyObject *resultobj = 0;
22733 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22734 wxKeyEvent *result = 0 ;
22735 int val1 ;
22736 int ecode1 = 0 ;
22737 PyObject * obj0 = 0 ;
22738 char * kwnames[] = {
22739 (char *) "eventType", NULL
22740 };
22741
22742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22743 if (obj0) {
22744 ecode1 = SWIG_AsVal_int(obj0, &val1);
22745 if (!SWIG_IsOK(ecode1)) {
22746 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22747 }
22748 arg1 = static_cast< wxEventType >(val1);
22749 }
22750 {
22751 PyThreadState* __tstate = wxPyBeginAllowThreads();
22752 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22753 wxPyEndAllowThreads(__tstate);
22754 if (PyErr_Occurred()) SWIG_fail;
22755 }
22756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22757 return resultobj;
22758 fail:
22759 return NULL;
22760 }
22761
22762
22763 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22764 PyObject *resultobj = 0;
22765 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22766 int result;
22767 void *argp1 = 0 ;
22768 int res1 = 0 ;
22769 PyObject *swig_obj[1] ;
22770
22771 if (!args) SWIG_fail;
22772 swig_obj[0] = args;
22773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22774 if (!SWIG_IsOK(res1)) {
22775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22776 }
22777 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22778 {
22779 PyThreadState* __tstate = wxPyBeginAllowThreads();
22780 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22781 wxPyEndAllowThreads(__tstate);
22782 if (PyErr_Occurred()) SWIG_fail;
22783 }
22784 resultobj = SWIG_From_int(static_cast< int >(result));
22785 return resultobj;
22786 fail:
22787 return NULL;
22788 }
22789
22790
22791 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22792 PyObject *resultobj = 0;
22793 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22794 bool result;
22795 void *argp1 = 0 ;
22796 int res1 = 0 ;
22797 PyObject *swig_obj[1] ;
22798
22799 if (!args) SWIG_fail;
22800 swig_obj[0] = args;
22801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22802 if (!SWIG_IsOK(res1)) {
22803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22804 }
22805 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22806 {
22807 PyThreadState* __tstate = wxPyBeginAllowThreads();
22808 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22809 wxPyEndAllowThreads(__tstate);
22810 if (PyErr_Occurred()) SWIG_fail;
22811 }
22812 {
22813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22814 }
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22822 PyObject *resultobj = 0;
22823 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22824 bool result;
22825 void *argp1 = 0 ;
22826 int res1 = 0 ;
22827 PyObject *swig_obj[1] ;
22828
22829 if (!args) SWIG_fail;
22830 swig_obj[0] = args;
22831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22832 if (!SWIG_IsOK(res1)) {
22833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22834 }
22835 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22836 {
22837 PyThreadState* __tstate = wxPyBeginAllowThreads();
22838 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22839 wxPyEndAllowThreads(__tstate);
22840 if (PyErr_Occurred()) SWIG_fail;
22841 }
22842 {
22843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22844 }
22845 return resultobj;
22846 fail:
22847 return NULL;
22848 }
22849
22850
22851 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22852 PyObject *resultobj = 0;
22853 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22854 bool result;
22855 void *argp1 = 0 ;
22856 int res1 = 0 ;
22857 PyObject *swig_obj[1] ;
22858
22859 if (!args) SWIG_fail;
22860 swig_obj[0] = args;
22861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22862 if (!SWIG_IsOK(res1)) {
22863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22864 }
22865 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22866 {
22867 PyThreadState* __tstate = wxPyBeginAllowThreads();
22868 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22869 wxPyEndAllowThreads(__tstate);
22870 if (PyErr_Occurred()) SWIG_fail;
22871 }
22872 {
22873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22874 }
22875 return resultobj;
22876 fail:
22877 return NULL;
22878 }
22879
22880
22881 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22882 PyObject *resultobj = 0;
22883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22884 bool result;
22885 void *argp1 = 0 ;
22886 int res1 = 0 ;
22887 PyObject *swig_obj[1] ;
22888
22889 if (!args) SWIG_fail;
22890 swig_obj[0] = args;
22891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22892 if (!SWIG_IsOK(res1)) {
22893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22894 }
22895 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 {
22903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22904 }
22905 return resultobj;
22906 fail:
22907 return NULL;
22908 }
22909
22910
22911 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22912 PyObject *resultobj = 0;
22913 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22914 bool result;
22915 void *argp1 = 0 ;
22916 int res1 = 0 ;
22917 PyObject *swig_obj[1] ;
22918
22919 if (!args) SWIG_fail;
22920 swig_obj[0] = args;
22921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22922 if (!SWIG_IsOK(res1)) {
22923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22924 }
22925 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22929 wxPyEndAllowThreads(__tstate);
22930 if (PyErr_Occurred()) SWIG_fail;
22931 }
22932 {
22933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22934 }
22935 return resultobj;
22936 fail:
22937 return NULL;
22938 }
22939
22940
22941 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22942 PyObject *resultobj = 0;
22943 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22944 bool result;
22945 void *argp1 = 0 ;
22946 int res1 = 0 ;
22947 PyObject *swig_obj[1] ;
22948
22949 if (!args) SWIG_fail;
22950 swig_obj[0] = args;
22951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22952 if (!SWIG_IsOK(res1)) {
22953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22954 }
22955 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22956 {
22957 PyThreadState* __tstate = wxPyBeginAllowThreads();
22958 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 {
22963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22964 }
22965 return resultobj;
22966 fail:
22967 return NULL;
22968 }
22969
22970
22971 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22972 PyObject *resultobj = 0;
22973 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22974 int result;
22975 void *argp1 = 0 ;
22976 int res1 = 0 ;
22977 PyObject *swig_obj[1] ;
22978
22979 if (!args) SWIG_fail;
22980 swig_obj[0] = args;
22981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22982 if (!SWIG_IsOK(res1)) {
22983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22984 }
22985 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22986 {
22987 PyThreadState* __tstate = wxPyBeginAllowThreads();
22988 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22989 wxPyEndAllowThreads(__tstate);
22990 if (PyErr_Occurred()) SWIG_fail;
22991 }
22992 resultobj = SWIG_From_int(static_cast< int >(result));
22993 return resultobj;
22994 fail:
22995 return NULL;
22996 }
22997
22998
22999 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23000 PyObject *resultobj = 0;
23001 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23002 int result;
23003 void *argp1 = 0 ;
23004 int res1 = 0 ;
23005 PyObject *swig_obj[1] ;
23006
23007 if (!args) SWIG_fail;
23008 swig_obj[0] = args;
23009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23010 if (!SWIG_IsOK(res1)) {
23011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23012 }
23013 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23014 {
23015 PyThreadState* __tstate = wxPyBeginAllowThreads();
23016 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
23017 wxPyEndAllowThreads(__tstate);
23018 if (PyErr_Occurred()) SWIG_fail;
23019 }
23020 resultobj = SWIG_From_int(static_cast< int >(result));
23021 return resultobj;
23022 fail:
23023 return NULL;
23024 }
23025
23026
23027 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23028 PyObject *resultobj = 0;
23029 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23030 int arg2 ;
23031 void *argp1 = 0 ;
23032 int res1 = 0 ;
23033 int val2 ;
23034 int ecode2 = 0 ;
23035 PyObject * obj0 = 0 ;
23036 PyObject * obj1 = 0 ;
23037 char * kwnames[] = {
23038 (char *) "self",(char *) "uniChar", NULL
23039 };
23040
23041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
23042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23043 if (!SWIG_IsOK(res1)) {
23044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23045 }
23046 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23047 ecode2 = SWIG_AsVal_int(obj1, &val2);
23048 if (!SWIG_IsOK(ecode2)) {
23049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
23050 }
23051 arg2 = static_cast< int >(val2);
23052 {
23053 PyThreadState* __tstate = wxPyBeginAllowThreads();
23054 wxKeyEvent_SetUnicodeKey(arg1,arg2);
23055 wxPyEndAllowThreads(__tstate);
23056 if (PyErr_Occurred()) SWIG_fail;
23057 }
23058 resultobj = SWIG_Py_Void();
23059 return resultobj;
23060 fail:
23061 return NULL;
23062 }
23063
23064
23065 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23066 PyObject *resultobj = 0;
23067 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23068 unsigned int result;
23069 void *argp1 = 0 ;
23070 int res1 = 0 ;
23071 PyObject *swig_obj[1] ;
23072
23073 if (!args) SWIG_fail;
23074 swig_obj[0] = args;
23075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23078 }
23079 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23080 {
23081 PyThreadState* __tstate = wxPyBeginAllowThreads();
23082 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
23083 wxPyEndAllowThreads(__tstate);
23084 if (PyErr_Occurred()) SWIG_fail;
23085 }
23086 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23094 PyObject *resultobj = 0;
23095 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23096 unsigned int result;
23097 void *argp1 = 0 ;
23098 int res1 = 0 ;
23099 PyObject *swig_obj[1] ;
23100
23101 if (!args) SWIG_fail;
23102 swig_obj[0] = args;
23103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23104 if (!SWIG_IsOK(res1)) {
23105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23106 }
23107 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23111 wxPyEndAllowThreads(__tstate);
23112 if (PyErr_Occurred()) SWIG_fail;
23113 }
23114 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23115 return resultobj;
23116 fail:
23117 return NULL;
23118 }
23119
23120
23121 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23122 PyObject *resultobj = 0;
23123 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23124 wxPoint result;
23125 void *argp1 = 0 ;
23126 int res1 = 0 ;
23127 PyObject *swig_obj[1] ;
23128
23129 if (!args) SWIG_fail;
23130 swig_obj[0] = args;
23131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23132 if (!SWIG_IsOK(res1)) {
23133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23134 }
23135 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23136 {
23137 PyThreadState* __tstate = wxPyBeginAllowThreads();
23138 result = (arg1)->GetPosition();
23139 wxPyEndAllowThreads(__tstate);
23140 if (PyErr_Occurred()) SWIG_fail;
23141 }
23142 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23143 return resultobj;
23144 fail:
23145 return NULL;
23146 }
23147
23148
23149 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23150 PyObject *resultobj = 0;
23151 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23152 long *arg2 = (long *) 0 ;
23153 long *arg3 = (long *) 0 ;
23154 void *argp1 = 0 ;
23155 int res1 = 0 ;
23156 long temp2 ;
23157 int res2 = SWIG_TMPOBJ ;
23158 long temp3 ;
23159 int res3 = SWIG_TMPOBJ ;
23160 PyObject *swig_obj[1] ;
23161
23162 arg2 = &temp2;
23163 arg3 = &temp3;
23164 if (!args) SWIG_fail;
23165 swig_obj[0] = args;
23166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23167 if (!SWIG_IsOK(res1)) {
23168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23169 }
23170 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23171 {
23172 PyThreadState* __tstate = wxPyBeginAllowThreads();
23173 (arg1)->GetPosition(arg2,arg3);
23174 wxPyEndAllowThreads(__tstate);
23175 if (PyErr_Occurred()) SWIG_fail;
23176 }
23177 resultobj = SWIG_Py_Void();
23178 if (SWIG_IsTmpObj(res2)) {
23179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23180 } else {
23181 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23183 }
23184 if (SWIG_IsTmpObj(res3)) {
23185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23186 } else {
23187 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23189 }
23190 return resultobj;
23191 fail:
23192 return NULL;
23193 }
23194
23195
23196 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23197 PyObject *resultobj = 0;
23198 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23199 int result;
23200 void *argp1 = 0 ;
23201 int res1 = 0 ;
23202 PyObject *swig_obj[1] ;
23203
23204 if (!args) SWIG_fail;
23205 swig_obj[0] = args;
23206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23207 if (!SWIG_IsOK(res1)) {
23208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23209 }
23210 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23211 {
23212 PyThreadState* __tstate = wxPyBeginAllowThreads();
23213 result = (int)((wxKeyEvent const *)arg1)->GetX();
23214 wxPyEndAllowThreads(__tstate);
23215 if (PyErr_Occurred()) SWIG_fail;
23216 }
23217 resultobj = SWIG_From_int(static_cast< int >(result));
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23225 PyObject *resultobj = 0;
23226 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23227 int result;
23228 void *argp1 = 0 ;
23229 int res1 = 0 ;
23230 PyObject *swig_obj[1] ;
23231
23232 if (!args) SWIG_fail;
23233 swig_obj[0] = args;
23234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23235 if (!SWIG_IsOK(res1)) {
23236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23237 }
23238 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 result = (int)((wxKeyEvent const *)arg1)->GetY();
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 resultobj = SWIG_From_int(static_cast< int >(result));
23246 return resultobj;
23247 fail:
23248 return NULL;
23249 }
23250
23251
23252 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23253 PyObject *resultobj = 0;
23254 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23255 int arg2 ;
23256 void *argp1 = 0 ;
23257 int res1 = 0 ;
23258 int val2 ;
23259 int ecode2 = 0 ;
23260 PyObject *swig_obj[2] ;
23261
23262 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23264 if (!SWIG_IsOK(res1)) {
23265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23266 }
23267 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23268 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23269 if (!SWIG_IsOK(ecode2)) {
23270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23271 }
23272 arg2 = static_cast< int >(val2);
23273 if (arg1) (arg1)->m_x = arg2;
23274
23275 resultobj = SWIG_Py_Void();
23276 return resultobj;
23277 fail:
23278 return NULL;
23279 }
23280
23281
23282 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23283 PyObject *resultobj = 0;
23284 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23285 int result;
23286 void *argp1 = 0 ;
23287 int res1 = 0 ;
23288 PyObject *swig_obj[1] ;
23289
23290 if (!args) SWIG_fail;
23291 swig_obj[0] = args;
23292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23293 if (!SWIG_IsOK(res1)) {
23294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23295 }
23296 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23297 result = (int) ((arg1)->m_x);
23298 resultobj = SWIG_From_int(static_cast< int >(result));
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23306 PyObject *resultobj = 0;
23307 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23308 int arg2 ;
23309 void *argp1 = 0 ;
23310 int res1 = 0 ;
23311 int val2 ;
23312 int ecode2 = 0 ;
23313 PyObject *swig_obj[2] ;
23314
23315 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23317 if (!SWIG_IsOK(res1)) {
23318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23319 }
23320 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23321 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23322 if (!SWIG_IsOK(ecode2)) {
23323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23324 }
23325 arg2 = static_cast< int >(val2);
23326 if (arg1) (arg1)->m_y = arg2;
23327
23328 resultobj = SWIG_Py_Void();
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23336 PyObject *resultobj = 0;
23337 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23338 int result;
23339 void *argp1 = 0 ;
23340 int res1 = 0 ;
23341 PyObject *swig_obj[1] ;
23342
23343 if (!args) SWIG_fail;
23344 swig_obj[0] = args;
23345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23346 if (!SWIG_IsOK(res1)) {
23347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23348 }
23349 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23350 result = (int) ((arg1)->m_y);
23351 resultobj = SWIG_From_int(static_cast< int >(result));
23352 return resultobj;
23353 fail:
23354 return NULL;
23355 }
23356
23357
23358 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23359 PyObject *resultobj = 0;
23360 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23361 long arg2 ;
23362 void *argp1 = 0 ;
23363 int res1 = 0 ;
23364 long val2 ;
23365 int ecode2 = 0 ;
23366 PyObject *swig_obj[2] ;
23367
23368 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23370 if (!SWIG_IsOK(res1)) {
23371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23372 }
23373 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23374 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23375 if (!SWIG_IsOK(ecode2)) {
23376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23377 }
23378 arg2 = static_cast< long >(val2);
23379 if (arg1) (arg1)->m_keyCode = arg2;
23380
23381 resultobj = SWIG_Py_Void();
23382 return resultobj;
23383 fail:
23384 return NULL;
23385 }
23386
23387
23388 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23389 PyObject *resultobj = 0;
23390 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23391 long result;
23392 void *argp1 = 0 ;
23393 int res1 = 0 ;
23394 PyObject *swig_obj[1] ;
23395
23396 if (!args) SWIG_fail;
23397 swig_obj[0] = args;
23398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23399 if (!SWIG_IsOK(res1)) {
23400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23401 }
23402 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23403 result = (long) ((arg1)->m_keyCode);
23404 resultobj = SWIG_From_long(static_cast< long >(result));
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412 PyObject *resultobj = 0;
23413 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23414 bool arg2 ;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 bool val2 ;
23418 int ecode2 = 0 ;
23419 PyObject *swig_obj[2] ;
23420
23421 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23423 if (!SWIG_IsOK(res1)) {
23424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23425 }
23426 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23427 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23428 if (!SWIG_IsOK(ecode2)) {
23429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23430 }
23431 arg2 = static_cast< bool >(val2);
23432 if (arg1) (arg1)->m_controlDown = arg2;
23433
23434 resultobj = SWIG_Py_Void();
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *resultobj = 0;
23443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23444 bool result;
23445 void *argp1 = 0 ;
23446 int res1 = 0 ;
23447 PyObject *swig_obj[1] ;
23448
23449 if (!args) SWIG_fail;
23450 swig_obj[0] = args;
23451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23452 if (!SWIG_IsOK(res1)) {
23453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23454 }
23455 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23456 result = (bool) ((arg1)->m_controlDown);
23457 {
23458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23459 }
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23467 PyObject *resultobj = 0;
23468 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23469 bool arg2 ;
23470 void *argp1 = 0 ;
23471 int res1 = 0 ;
23472 bool val2 ;
23473 int ecode2 = 0 ;
23474 PyObject *swig_obj[2] ;
23475
23476 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23478 if (!SWIG_IsOK(res1)) {
23479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23480 }
23481 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23482 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23483 if (!SWIG_IsOK(ecode2)) {
23484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23485 }
23486 arg2 = static_cast< bool >(val2);
23487 if (arg1) (arg1)->m_shiftDown = arg2;
23488
23489 resultobj = SWIG_Py_Void();
23490 return resultobj;
23491 fail:
23492 return NULL;
23493 }
23494
23495
23496 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23497 PyObject *resultobj = 0;
23498 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23499 bool result;
23500 void *argp1 = 0 ;
23501 int res1 = 0 ;
23502 PyObject *swig_obj[1] ;
23503
23504 if (!args) SWIG_fail;
23505 swig_obj[0] = args;
23506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23507 if (!SWIG_IsOK(res1)) {
23508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23509 }
23510 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23511 result = (bool) ((arg1)->m_shiftDown);
23512 {
23513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23514 }
23515 return resultobj;
23516 fail:
23517 return NULL;
23518 }
23519
23520
23521 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23522 PyObject *resultobj = 0;
23523 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23524 bool arg2 ;
23525 void *argp1 = 0 ;
23526 int res1 = 0 ;
23527 bool val2 ;
23528 int ecode2 = 0 ;
23529 PyObject *swig_obj[2] ;
23530
23531 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23533 if (!SWIG_IsOK(res1)) {
23534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23535 }
23536 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23537 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23538 if (!SWIG_IsOK(ecode2)) {
23539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23540 }
23541 arg2 = static_cast< bool >(val2);
23542 if (arg1) (arg1)->m_altDown = arg2;
23543
23544 resultobj = SWIG_Py_Void();
23545 return resultobj;
23546 fail:
23547 return NULL;
23548 }
23549
23550
23551 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23552 PyObject *resultobj = 0;
23553 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23554 bool result;
23555 void *argp1 = 0 ;
23556 int res1 = 0 ;
23557 PyObject *swig_obj[1] ;
23558
23559 if (!args) SWIG_fail;
23560 swig_obj[0] = args;
23561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23562 if (!SWIG_IsOK(res1)) {
23563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23564 }
23565 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23566 result = (bool) ((arg1)->m_altDown);
23567 {
23568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23569 }
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23577 PyObject *resultobj = 0;
23578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23579 bool arg2 ;
23580 void *argp1 = 0 ;
23581 int res1 = 0 ;
23582 bool val2 ;
23583 int ecode2 = 0 ;
23584 PyObject *swig_obj[2] ;
23585
23586 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23588 if (!SWIG_IsOK(res1)) {
23589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23590 }
23591 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23592 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23593 if (!SWIG_IsOK(ecode2)) {
23594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23595 }
23596 arg2 = static_cast< bool >(val2);
23597 if (arg1) (arg1)->m_metaDown = arg2;
23598
23599 resultobj = SWIG_Py_Void();
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23607 PyObject *resultobj = 0;
23608 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23609 bool result;
23610 void *argp1 = 0 ;
23611 int res1 = 0 ;
23612 PyObject *swig_obj[1] ;
23613
23614 if (!args) SWIG_fail;
23615 swig_obj[0] = args;
23616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23617 if (!SWIG_IsOK(res1)) {
23618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23619 }
23620 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23621 result = (bool) ((arg1)->m_metaDown);
23622 {
23623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23632 PyObject *resultobj = 0;
23633 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23634 bool arg2 ;
23635 void *argp1 = 0 ;
23636 int res1 = 0 ;
23637 bool val2 ;
23638 int ecode2 = 0 ;
23639 PyObject *swig_obj[2] ;
23640
23641 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23643 if (!SWIG_IsOK(res1)) {
23644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23645 }
23646 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23647 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23648 if (!SWIG_IsOK(ecode2)) {
23649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23650 }
23651 arg2 = static_cast< bool >(val2);
23652 if (arg1) (arg1)->m_scanCode = arg2;
23653
23654 resultobj = SWIG_Py_Void();
23655 return resultobj;
23656 fail:
23657 return NULL;
23658 }
23659
23660
23661 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23662 PyObject *resultobj = 0;
23663 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23664 bool result;
23665 void *argp1 = 0 ;
23666 int res1 = 0 ;
23667 PyObject *swig_obj[1] ;
23668
23669 if (!args) SWIG_fail;
23670 swig_obj[0] = args;
23671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23672 if (!SWIG_IsOK(res1)) {
23673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23674 }
23675 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23676 result = (bool) ((arg1)->m_scanCode);
23677 {
23678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23687 PyObject *resultobj = 0;
23688 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23689 unsigned int arg2 ;
23690 void *argp1 = 0 ;
23691 int res1 = 0 ;
23692 unsigned int val2 ;
23693 int ecode2 = 0 ;
23694 PyObject *swig_obj[2] ;
23695
23696 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23698 if (!SWIG_IsOK(res1)) {
23699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23700 }
23701 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23702 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23703 if (!SWIG_IsOK(ecode2)) {
23704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23705 }
23706 arg2 = static_cast< unsigned int >(val2);
23707 if (arg1) (arg1)->m_rawCode = arg2;
23708
23709 resultobj = SWIG_Py_Void();
23710 return resultobj;
23711 fail:
23712 return NULL;
23713 }
23714
23715
23716 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23717 PyObject *resultobj = 0;
23718 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23719 unsigned int result;
23720 void *argp1 = 0 ;
23721 int res1 = 0 ;
23722 PyObject *swig_obj[1] ;
23723
23724 if (!args) SWIG_fail;
23725 swig_obj[0] = args;
23726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23727 if (!SWIG_IsOK(res1)) {
23728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23729 }
23730 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23731 result = (unsigned int) ((arg1)->m_rawCode);
23732 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23733 return resultobj;
23734 fail:
23735 return NULL;
23736 }
23737
23738
23739 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23740 PyObject *resultobj = 0;
23741 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23742 unsigned int arg2 ;
23743 void *argp1 = 0 ;
23744 int res1 = 0 ;
23745 unsigned int val2 ;
23746 int ecode2 = 0 ;
23747 PyObject *swig_obj[2] ;
23748
23749 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23751 if (!SWIG_IsOK(res1)) {
23752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23753 }
23754 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23755 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23756 if (!SWIG_IsOK(ecode2)) {
23757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23758 }
23759 arg2 = static_cast< unsigned int >(val2);
23760 if (arg1) (arg1)->m_rawFlags = arg2;
23761
23762 resultobj = SWIG_Py_Void();
23763 return resultobj;
23764 fail:
23765 return NULL;
23766 }
23767
23768
23769 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23770 PyObject *resultobj = 0;
23771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23772 unsigned int result;
23773 void *argp1 = 0 ;
23774 int res1 = 0 ;
23775 PyObject *swig_obj[1] ;
23776
23777 if (!args) SWIG_fail;
23778 swig_obj[0] = args;
23779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23780 if (!SWIG_IsOK(res1)) {
23781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23782 }
23783 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23784 result = (unsigned int) ((arg1)->m_rawFlags);
23785 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23786 return resultobj;
23787 fail:
23788 return NULL;
23789 }
23790
23791
23792 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23793 PyObject *obj;
23794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23795 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23796 return SWIG_Py_Void();
23797 }
23798
23799 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800 return SWIG_Python_InitShadowInstance(args);
23801 }
23802
23803 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23804 PyObject *resultobj = 0;
23805 wxSize const &arg1_defvalue = wxDefaultSize ;
23806 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23807 int arg2 = (int) 0 ;
23808 wxSizeEvent *result = 0 ;
23809 wxSize temp1 ;
23810 int val2 ;
23811 int ecode2 = 0 ;
23812 PyObject * obj0 = 0 ;
23813 PyObject * obj1 = 0 ;
23814 char * kwnames[] = {
23815 (char *) "sz",(char *) "winid", NULL
23816 };
23817
23818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23819 if (obj0) {
23820 {
23821 arg1 = &temp1;
23822 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23823 }
23824 }
23825 if (obj1) {
23826 ecode2 = SWIG_AsVal_int(obj1, &val2);
23827 if (!SWIG_IsOK(ecode2)) {
23828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23829 }
23830 arg2 = static_cast< int >(val2);
23831 }
23832 {
23833 PyThreadState* __tstate = wxPyBeginAllowThreads();
23834 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23835 wxPyEndAllowThreads(__tstate);
23836 if (PyErr_Occurred()) SWIG_fail;
23837 }
23838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23839 return resultobj;
23840 fail:
23841 return NULL;
23842 }
23843
23844
23845 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23846 PyObject *resultobj = 0;
23847 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23848 wxSize result;
23849 void *argp1 = 0 ;
23850 int res1 = 0 ;
23851 PyObject *swig_obj[1] ;
23852
23853 if (!args) SWIG_fail;
23854 swig_obj[0] = args;
23855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23856 if (!SWIG_IsOK(res1)) {
23857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23858 }
23859 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23860 {
23861 PyThreadState* __tstate = wxPyBeginAllowThreads();
23862 result = ((wxSizeEvent const *)arg1)->GetSize();
23863 wxPyEndAllowThreads(__tstate);
23864 if (PyErr_Occurred()) SWIG_fail;
23865 }
23866 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23867 return resultobj;
23868 fail:
23869 return NULL;
23870 }
23871
23872
23873 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23874 PyObject *resultobj = 0;
23875 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23876 wxRect result;
23877 void *argp1 = 0 ;
23878 int res1 = 0 ;
23879 PyObject *swig_obj[1] ;
23880
23881 if (!args) SWIG_fail;
23882 swig_obj[0] = args;
23883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23884 if (!SWIG_IsOK(res1)) {
23885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23886 }
23887 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23888 {
23889 PyThreadState* __tstate = wxPyBeginAllowThreads();
23890 result = ((wxSizeEvent const *)arg1)->GetRect();
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23902 PyObject *resultobj = 0;
23903 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23904 wxRect arg2 ;
23905 void *argp1 = 0 ;
23906 int res1 = 0 ;
23907 void *argp2 ;
23908 int res2 = 0 ;
23909 PyObject * obj0 = 0 ;
23910 PyObject * obj1 = 0 ;
23911 char * kwnames[] = {
23912 (char *) "self",(char *) "rect", NULL
23913 };
23914
23915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23917 if (!SWIG_IsOK(res1)) {
23918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23919 }
23920 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23921 {
23922 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23923 if (!SWIG_IsOK(res2)) {
23924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23925 }
23926 if (!argp2) {
23927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23928 } else {
23929 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23930 arg2 = *temp;
23931 if (SWIG_IsNewObj(res2)) delete temp;
23932 }
23933 }
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 (arg1)->SetRect(arg2);
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 resultobj = SWIG_Py_Void();
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23948 PyObject *resultobj = 0;
23949 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23950 wxSize arg2 ;
23951 void *argp1 = 0 ;
23952 int res1 = 0 ;
23953 void *argp2 ;
23954 int res2 = 0 ;
23955 PyObject * obj0 = 0 ;
23956 PyObject * obj1 = 0 ;
23957 char * kwnames[] = {
23958 (char *) "self",(char *) "size", NULL
23959 };
23960
23961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23963 if (!SWIG_IsOK(res1)) {
23964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23965 }
23966 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23967 {
23968 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23969 if (!SWIG_IsOK(res2)) {
23970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23971 }
23972 if (!argp2) {
23973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23974 } else {
23975 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23976 arg2 = *temp;
23977 if (SWIG_IsNewObj(res2)) delete temp;
23978 }
23979 }
23980 {
23981 PyThreadState* __tstate = wxPyBeginAllowThreads();
23982 wxSizeEvent_SetSize(arg1,arg2);
23983 wxPyEndAllowThreads(__tstate);
23984 if (PyErr_Occurred()) SWIG_fail;
23985 }
23986 resultobj = SWIG_Py_Void();
23987 return resultobj;
23988 fail:
23989 return NULL;
23990 }
23991
23992
23993 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23994 PyObject *resultobj = 0;
23995 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23996 wxSize *arg2 = (wxSize *) 0 ;
23997 void *argp1 = 0 ;
23998 int res1 = 0 ;
23999 void *argp2 = 0 ;
24000 int res2 = 0 ;
24001 PyObject *swig_obj[2] ;
24002
24003 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
24004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24005 if (!SWIG_IsOK(res1)) {
24006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24007 }
24008 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24009 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
24010 if (!SWIG_IsOK(res2)) {
24011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
24012 }
24013 arg2 = reinterpret_cast< wxSize * >(argp2);
24014 if (arg1) (arg1)->m_size = *arg2;
24015
24016 resultobj = SWIG_Py_Void();
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24024 PyObject *resultobj = 0;
24025 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24026 wxSize *result = 0 ;
24027 void *argp1 = 0 ;
24028 int res1 = 0 ;
24029 PyObject *swig_obj[1] ;
24030
24031 if (!args) SWIG_fail;
24032 swig_obj[0] = args;
24033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24034 if (!SWIG_IsOK(res1)) {
24035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24036 }
24037 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24038 result = (wxSize *)& ((arg1)->m_size);
24039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
24040 return resultobj;
24041 fail:
24042 return NULL;
24043 }
24044
24045
24046 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24047 PyObject *resultobj = 0;
24048 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24049 wxRect *arg2 = (wxRect *) 0 ;
24050 void *argp1 = 0 ;
24051 int res1 = 0 ;
24052 void *argp2 = 0 ;
24053 int res2 = 0 ;
24054 PyObject *swig_obj[2] ;
24055
24056 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
24057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24058 if (!SWIG_IsOK(res1)) {
24059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24060 }
24061 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24062 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
24063 if (!SWIG_IsOK(res2)) {
24064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
24065 }
24066 arg2 = reinterpret_cast< wxRect * >(argp2);
24067 if (arg1) (arg1)->m_rect = *arg2;
24068
24069 resultobj = SWIG_Py_Void();
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24077 PyObject *resultobj = 0;
24078 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24079 wxRect *result = 0 ;
24080 void *argp1 = 0 ;
24081 int res1 = 0 ;
24082 PyObject *swig_obj[1] ;
24083
24084 if (!args) SWIG_fail;
24085 swig_obj[0] = args;
24086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24087 if (!SWIG_IsOK(res1)) {
24088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24089 }
24090 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24091 result = (wxRect *)& ((arg1)->m_rect);
24092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
24093 return resultobj;
24094 fail:
24095 return NULL;
24096 }
24097
24098
24099 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24100 PyObject *obj;
24101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24102 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
24103 return SWIG_Py_Void();
24104 }
24105
24106 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24107 return SWIG_Python_InitShadowInstance(args);
24108 }
24109
24110 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24111 PyObject *resultobj = 0;
24112 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24113 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24114 int arg2 = (int) 0 ;
24115 wxMoveEvent *result = 0 ;
24116 wxPoint temp1 ;
24117 int val2 ;
24118 int ecode2 = 0 ;
24119 PyObject * obj0 = 0 ;
24120 PyObject * obj1 = 0 ;
24121 char * kwnames[] = {
24122 (char *) "pos",(char *) "winid", NULL
24123 };
24124
24125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24126 if (obj0) {
24127 {
24128 arg1 = &temp1;
24129 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24130 }
24131 }
24132 if (obj1) {
24133 ecode2 = SWIG_AsVal_int(obj1, &val2);
24134 if (!SWIG_IsOK(ecode2)) {
24135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24136 }
24137 arg2 = static_cast< int >(val2);
24138 }
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24142 wxPyEndAllowThreads(__tstate);
24143 if (PyErr_Occurred()) SWIG_fail;
24144 }
24145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24146 return resultobj;
24147 fail:
24148 return NULL;
24149 }
24150
24151
24152 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24153 PyObject *resultobj = 0;
24154 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24155 wxPoint result;
24156 void *argp1 = 0 ;
24157 int res1 = 0 ;
24158 PyObject *swig_obj[1] ;
24159
24160 if (!args) SWIG_fail;
24161 swig_obj[0] = args;
24162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24163 if (!SWIG_IsOK(res1)) {
24164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24165 }
24166 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24167 {
24168 PyThreadState* __tstate = wxPyBeginAllowThreads();
24169 result = ((wxMoveEvent const *)arg1)->GetPosition();
24170 wxPyEndAllowThreads(__tstate);
24171 if (PyErr_Occurred()) SWIG_fail;
24172 }
24173 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24174 return resultobj;
24175 fail:
24176 return NULL;
24177 }
24178
24179
24180 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24181 PyObject *resultobj = 0;
24182 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24183 wxRect result;
24184 void *argp1 = 0 ;
24185 int res1 = 0 ;
24186 PyObject *swig_obj[1] ;
24187
24188 if (!args) SWIG_fail;
24189 swig_obj[0] = args;
24190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24191 if (!SWIG_IsOK(res1)) {
24192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24193 }
24194 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24195 {
24196 PyThreadState* __tstate = wxPyBeginAllowThreads();
24197 result = ((wxMoveEvent const *)arg1)->GetRect();
24198 wxPyEndAllowThreads(__tstate);
24199 if (PyErr_Occurred()) SWIG_fail;
24200 }
24201 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24202 return resultobj;
24203 fail:
24204 return NULL;
24205 }
24206
24207
24208 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24209 PyObject *resultobj = 0;
24210 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24211 wxRect *arg2 = 0 ;
24212 void *argp1 = 0 ;
24213 int res1 = 0 ;
24214 wxRect temp2 ;
24215 PyObject * obj0 = 0 ;
24216 PyObject * obj1 = 0 ;
24217 char * kwnames[] = {
24218 (char *) "self",(char *) "rect", NULL
24219 };
24220
24221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24223 if (!SWIG_IsOK(res1)) {
24224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24225 }
24226 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24227 {
24228 arg2 = &temp2;
24229 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24230 }
24231 {
24232 PyThreadState* __tstate = wxPyBeginAllowThreads();
24233 (arg1)->SetRect((wxRect const &)*arg2);
24234 wxPyEndAllowThreads(__tstate);
24235 if (PyErr_Occurred()) SWIG_fail;
24236 }
24237 resultobj = SWIG_Py_Void();
24238 return resultobj;
24239 fail:
24240 return NULL;
24241 }
24242
24243
24244 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24245 PyObject *resultobj = 0;
24246 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24247 wxPoint *arg2 = 0 ;
24248 void *argp1 = 0 ;
24249 int res1 = 0 ;
24250 wxPoint temp2 ;
24251 PyObject * obj0 = 0 ;
24252 PyObject * obj1 = 0 ;
24253 char * kwnames[] = {
24254 (char *) "self",(char *) "pos", NULL
24255 };
24256
24257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24259 if (!SWIG_IsOK(res1)) {
24260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24261 }
24262 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24263 {
24264 arg2 = &temp2;
24265 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24266 }
24267 {
24268 PyThreadState* __tstate = wxPyBeginAllowThreads();
24269 (arg1)->SetPosition((wxPoint const &)*arg2);
24270 wxPyEndAllowThreads(__tstate);
24271 if (PyErr_Occurred()) SWIG_fail;
24272 }
24273 resultobj = SWIG_Py_Void();
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24281 PyObject *obj;
24282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24283 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24284 return SWIG_Py_Void();
24285 }
24286
24287 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24288 return SWIG_Python_InitShadowInstance(args);
24289 }
24290
24291 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24292 PyObject *resultobj = 0;
24293 int arg1 = (int) 0 ;
24294 wxPaintEvent *result = 0 ;
24295 int val1 ;
24296 int ecode1 = 0 ;
24297 PyObject * obj0 = 0 ;
24298 char * kwnames[] = {
24299 (char *) "Id", NULL
24300 };
24301
24302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24303 if (obj0) {
24304 ecode1 = SWIG_AsVal_int(obj0, &val1);
24305 if (!SWIG_IsOK(ecode1)) {
24306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24307 }
24308 arg1 = static_cast< int >(val1);
24309 }
24310 {
24311 PyThreadState* __tstate = wxPyBeginAllowThreads();
24312 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24313 wxPyEndAllowThreads(__tstate);
24314 if (PyErr_Occurred()) SWIG_fail;
24315 }
24316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24317 return resultobj;
24318 fail:
24319 return NULL;
24320 }
24321
24322
24323 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24324 PyObject *obj;
24325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24326 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24327 return SWIG_Py_Void();
24328 }
24329
24330 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24331 return SWIG_Python_InitShadowInstance(args);
24332 }
24333
24334 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24335 PyObject *resultobj = 0;
24336 int arg1 = (int) 0 ;
24337 wxNcPaintEvent *result = 0 ;
24338 int val1 ;
24339 int ecode1 = 0 ;
24340 PyObject * obj0 = 0 ;
24341 char * kwnames[] = {
24342 (char *) "winid", NULL
24343 };
24344
24345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24346 if (obj0) {
24347 ecode1 = SWIG_AsVal_int(obj0, &val1);
24348 if (!SWIG_IsOK(ecode1)) {
24349 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24350 }
24351 arg1 = static_cast< int >(val1);
24352 }
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24356 wxPyEndAllowThreads(__tstate);
24357 if (PyErr_Occurred()) SWIG_fail;
24358 }
24359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24360 return resultobj;
24361 fail:
24362 return NULL;
24363 }
24364
24365
24366 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24367 PyObject *obj;
24368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24369 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24370 return SWIG_Py_Void();
24371 }
24372
24373 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24374 return SWIG_Python_InitShadowInstance(args);
24375 }
24376
24377 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24378 PyObject *resultobj = 0;
24379 int arg1 = (int) 0 ;
24380 wxDC *arg2 = (wxDC *) NULL ;
24381 wxEraseEvent *result = 0 ;
24382 int val1 ;
24383 int ecode1 = 0 ;
24384 void *argp2 = 0 ;
24385 int res2 = 0 ;
24386 PyObject * obj0 = 0 ;
24387 PyObject * obj1 = 0 ;
24388 char * kwnames[] = {
24389 (char *) "Id",(char *) "dc", NULL
24390 };
24391
24392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24393 if (obj0) {
24394 ecode1 = SWIG_AsVal_int(obj0, &val1);
24395 if (!SWIG_IsOK(ecode1)) {
24396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24397 }
24398 arg1 = static_cast< int >(val1);
24399 }
24400 if (obj1) {
24401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24402 if (!SWIG_IsOK(res2)) {
24403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24404 }
24405 arg2 = reinterpret_cast< wxDC * >(argp2);
24406 }
24407 {
24408 PyThreadState* __tstate = wxPyBeginAllowThreads();
24409 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24410 wxPyEndAllowThreads(__tstate);
24411 if (PyErr_Occurred()) SWIG_fail;
24412 }
24413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24414 return resultobj;
24415 fail:
24416 return NULL;
24417 }
24418
24419
24420 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24421 PyObject *resultobj = 0;
24422 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24423 wxDC *result = 0 ;
24424 void *argp1 = 0 ;
24425 int res1 = 0 ;
24426 PyObject *swig_obj[1] ;
24427
24428 if (!args) SWIG_fail;
24429 swig_obj[0] = args;
24430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24431 if (!SWIG_IsOK(res1)) {
24432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24433 }
24434 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24435 {
24436 PyThreadState* __tstate = wxPyBeginAllowThreads();
24437 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24438 wxPyEndAllowThreads(__tstate);
24439 if (PyErr_Occurred()) SWIG_fail;
24440 }
24441 {
24442 resultobj = wxPyMake_wxObject(result, (bool)0);
24443 }
24444 return resultobj;
24445 fail:
24446 return NULL;
24447 }
24448
24449
24450 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24451 PyObject *obj;
24452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24453 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24454 return SWIG_Py_Void();
24455 }
24456
24457 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24458 return SWIG_Python_InitShadowInstance(args);
24459 }
24460
24461 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24462 PyObject *resultobj = 0;
24463 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24464 int arg2 = (int) 0 ;
24465 wxFocusEvent *result = 0 ;
24466 int val1 ;
24467 int ecode1 = 0 ;
24468 int val2 ;
24469 int ecode2 = 0 ;
24470 PyObject * obj0 = 0 ;
24471 PyObject * obj1 = 0 ;
24472 char * kwnames[] = {
24473 (char *) "type",(char *) "winid", NULL
24474 };
24475
24476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24477 if (obj0) {
24478 ecode1 = SWIG_AsVal_int(obj0, &val1);
24479 if (!SWIG_IsOK(ecode1)) {
24480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24481 }
24482 arg1 = static_cast< wxEventType >(val1);
24483 }
24484 if (obj1) {
24485 ecode2 = SWIG_AsVal_int(obj1, &val2);
24486 if (!SWIG_IsOK(ecode2)) {
24487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24488 }
24489 arg2 = static_cast< int >(val2);
24490 }
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24494 wxPyEndAllowThreads(__tstate);
24495 if (PyErr_Occurred()) SWIG_fail;
24496 }
24497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24498 return resultobj;
24499 fail:
24500 return NULL;
24501 }
24502
24503
24504 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24505 PyObject *resultobj = 0;
24506 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24507 wxWindow *result = 0 ;
24508 void *argp1 = 0 ;
24509 int res1 = 0 ;
24510 PyObject *swig_obj[1] ;
24511
24512 if (!args) SWIG_fail;
24513 swig_obj[0] = args;
24514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24515 if (!SWIG_IsOK(res1)) {
24516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24517 }
24518 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24519 {
24520 PyThreadState* __tstate = wxPyBeginAllowThreads();
24521 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24522 wxPyEndAllowThreads(__tstate);
24523 if (PyErr_Occurred()) SWIG_fail;
24524 }
24525 {
24526 resultobj = wxPyMake_wxObject(result, (bool)0);
24527 }
24528 return resultobj;
24529 fail:
24530 return NULL;
24531 }
24532
24533
24534 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24535 PyObject *resultobj = 0;
24536 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24537 wxWindow *arg2 = (wxWindow *) 0 ;
24538 void *argp1 = 0 ;
24539 int res1 = 0 ;
24540 void *argp2 = 0 ;
24541 int res2 = 0 ;
24542 PyObject * obj0 = 0 ;
24543 PyObject * obj1 = 0 ;
24544 char * kwnames[] = {
24545 (char *) "self",(char *) "win", NULL
24546 };
24547
24548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24550 if (!SWIG_IsOK(res1)) {
24551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24552 }
24553 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24554 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24555 if (!SWIG_IsOK(res2)) {
24556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24557 }
24558 arg2 = reinterpret_cast< wxWindow * >(argp2);
24559 {
24560 PyThreadState* __tstate = wxPyBeginAllowThreads();
24561 (arg1)->SetWindow(arg2);
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 resultobj = SWIG_Py_Void();
24566 return resultobj;
24567 fail:
24568 return NULL;
24569 }
24570
24571
24572 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24573 PyObject *obj;
24574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24575 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24576 return SWIG_Py_Void();
24577 }
24578
24579 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24580 return SWIG_Python_InitShadowInstance(args);
24581 }
24582
24583 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24584 PyObject *resultobj = 0;
24585 wxWindow *arg1 = (wxWindow *) NULL ;
24586 wxChildFocusEvent *result = 0 ;
24587 void *argp1 = 0 ;
24588 int res1 = 0 ;
24589 PyObject * obj0 = 0 ;
24590 char * kwnames[] = {
24591 (char *) "win", NULL
24592 };
24593
24594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24595 if (obj0) {
24596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24597 if (!SWIG_IsOK(res1)) {
24598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24599 }
24600 arg1 = reinterpret_cast< wxWindow * >(argp1);
24601 }
24602 {
24603 PyThreadState* __tstate = wxPyBeginAllowThreads();
24604 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24605 wxPyEndAllowThreads(__tstate);
24606 if (PyErr_Occurred()) SWIG_fail;
24607 }
24608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24616 PyObject *resultobj = 0;
24617 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24618 wxWindow *result = 0 ;
24619 void *argp1 = 0 ;
24620 int res1 = 0 ;
24621 PyObject *swig_obj[1] ;
24622
24623 if (!args) SWIG_fail;
24624 swig_obj[0] = args;
24625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24626 if (!SWIG_IsOK(res1)) {
24627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24628 }
24629 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24630 {
24631 PyThreadState* __tstate = wxPyBeginAllowThreads();
24632 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24633 wxPyEndAllowThreads(__tstate);
24634 if (PyErr_Occurred()) SWIG_fail;
24635 }
24636 {
24637 resultobj = wxPyMake_wxObject(result, (bool)0);
24638 }
24639 return resultobj;
24640 fail:
24641 return NULL;
24642 }
24643
24644
24645 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24646 PyObject *obj;
24647 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24648 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24649 return SWIG_Py_Void();
24650 }
24651
24652 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24653 return SWIG_Python_InitShadowInstance(args);
24654 }
24655
24656 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24657 PyObject *resultobj = 0;
24658 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24659 bool arg2 = (bool) true ;
24660 int arg3 = (int) 0 ;
24661 wxActivateEvent *result = 0 ;
24662 int val1 ;
24663 int ecode1 = 0 ;
24664 bool val2 ;
24665 int ecode2 = 0 ;
24666 int val3 ;
24667 int ecode3 = 0 ;
24668 PyObject * obj0 = 0 ;
24669 PyObject * obj1 = 0 ;
24670 PyObject * obj2 = 0 ;
24671 char * kwnames[] = {
24672 (char *) "type",(char *) "active",(char *) "Id", NULL
24673 };
24674
24675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24676 if (obj0) {
24677 ecode1 = SWIG_AsVal_int(obj0, &val1);
24678 if (!SWIG_IsOK(ecode1)) {
24679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24680 }
24681 arg1 = static_cast< wxEventType >(val1);
24682 }
24683 if (obj1) {
24684 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24685 if (!SWIG_IsOK(ecode2)) {
24686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24687 }
24688 arg2 = static_cast< bool >(val2);
24689 }
24690 if (obj2) {
24691 ecode3 = SWIG_AsVal_int(obj2, &val3);
24692 if (!SWIG_IsOK(ecode3)) {
24693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24694 }
24695 arg3 = static_cast< int >(val3);
24696 }
24697 {
24698 PyThreadState* __tstate = wxPyBeginAllowThreads();
24699 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24700 wxPyEndAllowThreads(__tstate);
24701 if (PyErr_Occurred()) SWIG_fail;
24702 }
24703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24704 return resultobj;
24705 fail:
24706 return NULL;
24707 }
24708
24709
24710 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24711 PyObject *resultobj = 0;
24712 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24713 bool result;
24714 void *argp1 = 0 ;
24715 int res1 = 0 ;
24716 PyObject *swig_obj[1] ;
24717
24718 if (!args) SWIG_fail;
24719 swig_obj[0] = args;
24720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24721 if (!SWIG_IsOK(res1)) {
24722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24723 }
24724 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 {
24732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24733 }
24734 return resultobj;
24735 fail:
24736 return NULL;
24737 }
24738
24739
24740 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24741 PyObject *obj;
24742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24743 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24744 return SWIG_Py_Void();
24745 }
24746
24747 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24748 return SWIG_Python_InitShadowInstance(args);
24749 }
24750
24751 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24752 PyObject *resultobj = 0;
24753 int arg1 = (int) 0 ;
24754 wxInitDialogEvent *result = 0 ;
24755 int val1 ;
24756 int ecode1 = 0 ;
24757 PyObject * obj0 = 0 ;
24758 char * kwnames[] = {
24759 (char *) "Id", NULL
24760 };
24761
24762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24763 if (obj0) {
24764 ecode1 = SWIG_AsVal_int(obj0, &val1);
24765 if (!SWIG_IsOK(ecode1)) {
24766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24767 }
24768 arg1 = static_cast< int >(val1);
24769 }
24770 {
24771 PyThreadState* __tstate = wxPyBeginAllowThreads();
24772 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24773 wxPyEndAllowThreads(__tstate);
24774 if (PyErr_Occurred()) SWIG_fail;
24775 }
24776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24777 return resultobj;
24778 fail:
24779 return NULL;
24780 }
24781
24782
24783 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24784 PyObject *obj;
24785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24786 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24787 return SWIG_Py_Void();
24788 }
24789
24790 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24791 return SWIG_Python_InitShadowInstance(args);
24792 }
24793
24794 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj = 0;
24796 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24797 int arg2 = (int) 0 ;
24798 wxMenu *arg3 = (wxMenu *) NULL ;
24799 wxMenuEvent *result = 0 ;
24800 int val1 ;
24801 int ecode1 = 0 ;
24802 int val2 ;
24803 int ecode2 = 0 ;
24804 void *argp3 = 0 ;
24805 int res3 = 0 ;
24806 PyObject * obj0 = 0 ;
24807 PyObject * obj1 = 0 ;
24808 PyObject * obj2 = 0 ;
24809 char * kwnames[] = {
24810 (char *) "type",(char *) "winid",(char *) "menu", NULL
24811 };
24812
24813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24814 if (obj0) {
24815 ecode1 = SWIG_AsVal_int(obj0, &val1);
24816 if (!SWIG_IsOK(ecode1)) {
24817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24818 }
24819 arg1 = static_cast< wxEventType >(val1);
24820 }
24821 if (obj1) {
24822 ecode2 = SWIG_AsVal_int(obj1, &val2);
24823 if (!SWIG_IsOK(ecode2)) {
24824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24825 }
24826 arg2 = static_cast< int >(val2);
24827 }
24828 if (obj2) {
24829 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24830 if (!SWIG_IsOK(res3)) {
24831 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24832 }
24833 arg3 = reinterpret_cast< wxMenu * >(argp3);
24834 }
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24849 PyObject *resultobj = 0;
24850 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24851 int 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_wxMenuEvent, 0 | 0 );
24859 if (!SWIG_IsOK(res1)) {
24860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24861 }
24862 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24866 wxPyEndAllowThreads(__tstate);
24867 if (PyErr_Occurred()) SWIG_fail;
24868 }
24869 resultobj = SWIG_From_int(static_cast< int >(result));
24870 return resultobj;
24871 fail:
24872 return NULL;
24873 }
24874
24875
24876 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24877 PyObject *resultobj = 0;
24878 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24879 bool result;
24880 void *argp1 = 0 ;
24881 int res1 = 0 ;
24882 PyObject *swig_obj[1] ;
24883
24884 if (!args) SWIG_fail;
24885 swig_obj[0] = args;
24886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24887 if (!SWIG_IsOK(res1)) {
24888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24889 }
24890 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 {
24898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24899 }
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24907 PyObject *resultobj = 0;
24908 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24909 wxMenu *result = 0 ;
24910 void *argp1 = 0 ;
24911 int res1 = 0 ;
24912 PyObject *swig_obj[1] ;
24913
24914 if (!args) SWIG_fail;
24915 swig_obj[0] = args;
24916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24917 if (!SWIG_IsOK(res1)) {
24918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24919 }
24920 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24921 {
24922 PyThreadState* __tstate = wxPyBeginAllowThreads();
24923 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24924 wxPyEndAllowThreads(__tstate);
24925 if (PyErr_Occurred()) SWIG_fail;
24926 }
24927 {
24928 resultobj = wxPyMake_wxObject(result, (bool)0);
24929 }
24930 return resultobj;
24931 fail:
24932 return NULL;
24933 }
24934
24935
24936 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24937 PyObject *obj;
24938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24939 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24940 return SWIG_Py_Void();
24941 }
24942
24943 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24944 return SWIG_Python_InitShadowInstance(args);
24945 }
24946
24947 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24948 PyObject *resultobj = 0;
24949 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24950 int arg2 = (int) 0 ;
24951 wxCloseEvent *result = 0 ;
24952 int val1 ;
24953 int ecode1 = 0 ;
24954 int val2 ;
24955 int ecode2 = 0 ;
24956 PyObject * obj0 = 0 ;
24957 PyObject * obj1 = 0 ;
24958 char * kwnames[] = {
24959 (char *) "type",(char *) "winid", NULL
24960 };
24961
24962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24963 if (obj0) {
24964 ecode1 = SWIG_AsVal_int(obj0, &val1);
24965 if (!SWIG_IsOK(ecode1)) {
24966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24967 }
24968 arg1 = static_cast< wxEventType >(val1);
24969 }
24970 if (obj1) {
24971 ecode2 = SWIG_AsVal_int(obj1, &val2);
24972 if (!SWIG_IsOK(ecode2)) {
24973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24974 }
24975 arg2 = static_cast< int >(val2);
24976 }
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24980 wxPyEndAllowThreads(__tstate);
24981 if (PyErr_Occurred()) SWIG_fail;
24982 }
24983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24984 return resultobj;
24985 fail:
24986 return NULL;
24987 }
24988
24989
24990 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24991 PyObject *resultobj = 0;
24992 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24993 bool arg2 ;
24994 void *argp1 = 0 ;
24995 int res1 = 0 ;
24996 bool val2 ;
24997 int ecode2 = 0 ;
24998 PyObject * obj0 = 0 ;
24999 PyObject * obj1 = 0 ;
25000 char * kwnames[] = {
25001 (char *) "self",(char *) "logOff", NULL
25002 };
25003
25004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
25005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25006 if (!SWIG_IsOK(res1)) {
25007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25008 }
25009 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25010 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25011 if (!SWIG_IsOK(ecode2)) {
25012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
25013 }
25014 arg2 = static_cast< bool >(val2);
25015 {
25016 PyThreadState* __tstate = wxPyBeginAllowThreads();
25017 (arg1)->SetLoggingOff(arg2);
25018 wxPyEndAllowThreads(__tstate);
25019 if (PyErr_Occurred()) SWIG_fail;
25020 }
25021 resultobj = SWIG_Py_Void();
25022 return resultobj;
25023 fail:
25024 return NULL;
25025 }
25026
25027
25028 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25029 PyObject *resultobj = 0;
25030 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25031 bool result;
25032 void *argp1 = 0 ;
25033 int res1 = 0 ;
25034 PyObject *swig_obj[1] ;
25035
25036 if (!args) SWIG_fail;
25037 swig_obj[0] = args;
25038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25039 if (!SWIG_IsOK(res1)) {
25040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25041 }
25042 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25043 {
25044 PyThreadState* __tstate = wxPyBeginAllowThreads();
25045 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
25046 wxPyEndAllowThreads(__tstate);
25047 if (PyErr_Occurred()) SWIG_fail;
25048 }
25049 {
25050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25051 }
25052 return resultobj;
25053 fail:
25054 return NULL;
25055 }
25056
25057
25058 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25059 PyObject *resultobj = 0;
25060 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25061 bool arg2 = (bool) true ;
25062 void *argp1 = 0 ;
25063 int res1 = 0 ;
25064 bool val2 ;
25065 int ecode2 = 0 ;
25066 PyObject * obj0 = 0 ;
25067 PyObject * obj1 = 0 ;
25068 char * kwnames[] = {
25069 (char *) "self",(char *) "veto", NULL
25070 };
25071
25072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
25073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25074 if (!SWIG_IsOK(res1)) {
25075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25076 }
25077 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25078 if (obj1) {
25079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25080 if (!SWIG_IsOK(ecode2)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
25082 }
25083 arg2 = static_cast< bool >(val2);
25084 }
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 (arg1)->Veto(arg2);
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_Py_Void();
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25099 PyObject *resultobj = 0;
25100 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25101 bool result;
25102 void *argp1 = 0 ;
25103 int res1 = 0 ;
25104 PyObject *swig_obj[1] ;
25105
25106 if (!args) SWIG_fail;
25107 swig_obj[0] = args;
25108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25109 if (!SWIG_IsOK(res1)) {
25110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25111 }
25112 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 {
25120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25121 }
25122 return resultobj;
25123 fail:
25124 return NULL;
25125 }
25126
25127
25128 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25129 PyObject *resultobj = 0;
25130 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25131 bool arg2 ;
25132 void *argp1 = 0 ;
25133 int res1 = 0 ;
25134 bool val2 ;
25135 int ecode2 = 0 ;
25136 PyObject * obj0 = 0 ;
25137 PyObject * obj1 = 0 ;
25138 char * kwnames[] = {
25139 (char *) "self",(char *) "canVeto", NULL
25140 };
25141
25142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25144 if (!SWIG_IsOK(res1)) {
25145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25146 }
25147 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25148 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25149 if (!SWIG_IsOK(ecode2)) {
25150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25151 }
25152 arg2 = static_cast< bool >(val2);
25153 {
25154 PyThreadState* __tstate = wxPyBeginAllowThreads();
25155 (arg1)->SetCanVeto(arg2);
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 resultobj = SWIG_Py_Void();
25160 return resultobj;
25161 fail:
25162 return NULL;
25163 }
25164
25165
25166 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25167 PyObject *resultobj = 0;
25168 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25169 bool result;
25170 void *argp1 = 0 ;
25171 int res1 = 0 ;
25172 PyObject *swig_obj[1] ;
25173
25174 if (!args) SWIG_fail;
25175 swig_obj[0] = args;
25176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25177 if (!SWIG_IsOK(res1)) {
25178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25179 }
25180 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 {
25188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25189 }
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25197 PyObject *obj;
25198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25199 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25200 return SWIG_Py_Void();
25201 }
25202
25203 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25204 return SWIG_Python_InitShadowInstance(args);
25205 }
25206
25207 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25208 PyObject *resultobj = 0;
25209 int arg1 = (int) 0 ;
25210 bool arg2 = (bool) false ;
25211 wxShowEvent *result = 0 ;
25212 int val1 ;
25213 int ecode1 = 0 ;
25214 bool val2 ;
25215 int ecode2 = 0 ;
25216 PyObject * obj0 = 0 ;
25217 PyObject * obj1 = 0 ;
25218 char * kwnames[] = {
25219 (char *) "winid",(char *) "show", NULL
25220 };
25221
25222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25223 if (obj0) {
25224 ecode1 = SWIG_AsVal_int(obj0, &val1);
25225 if (!SWIG_IsOK(ecode1)) {
25226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25227 }
25228 arg1 = static_cast< int >(val1);
25229 }
25230 if (obj1) {
25231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25232 if (!SWIG_IsOK(ecode2)) {
25233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25234 }
25235 arg2 = static_cast< bool >(val2);
25236 }
25237 {
25238 PyThreadState* __tstate = wxPyBeginAllowThreads();
25239 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25244 return resultobj;
25245 fail:
25246 return NULL;
25247 }
25248
25249
25250 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25251 PyObject *resultobj = 0;
25252 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25253 bool arg2 ;
25254 void *argp1 = 0 ;
25255 int res1 = 0 ;
25256 bool val2 ;
25257 int ecode2 = 0 ;
25258 PyObject * obj0 = 0 ;
25259 PyObject * obj1 = 0 ;
25260 char * kwnames[] = {
25261 (char *) "self",(char *) "show", NULL
25262 };
25263
25264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25266 if (!SWIG_IsOK(res1)) {
25267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25268 }
25269 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25270 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25271 if (!SWIG_IsOK(ecode2)) {
25272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25273 }
25274 arg2 = static_cast< bool >(val2);
25275 {
25276 PyThreadState* __tstate = wxPyBeginAllowThreads();
25277 (arg1)->SetShow(arg2);
25278 wxPyEndAllowThreads(__tstate);
25279 if (PyErr_Occurred()) SWIG_fail;
25280 }
25281 resultobj = SWIG_Py_Void();
25282 return resultobj;
25283 fail:
25284 return NULL;
25285 }
25286
25287
25288 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25289 PyObject *resultobj = 0;
25290 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25291 bool result;
25292 void *argp1 = 0 ;
25293 int res1 = 0 ;
25294 PyObject *swig_obj[1] ;
25295
25296 if (!args) SWIG_fail;
25297 swig_obj[0] = args;
25298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25299 if (!SWIG_IsOK(res1)) {
25300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25301 }
25302 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25303 {
25304 PyThreadState* __tstate = wxPyBeginAllowThreads();
25305 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25306 wxPyEndAllowThreads(__tstate);
25307 if (PyErr_Occurred()) SWIG_fail;
25308 }
25309 {
25310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25311 }
25312 return resultobj;
25313 fail:
25314 return NULL;
25315 }
25316
25317
25318 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25319 PyObject *obj;
25320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25321 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25322 return SWIG_Py_Void();
25323 }
25324
25325 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25326 return SWIG_Python_InitShadowInstance(args);
25327 }
25328
25329 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25330 PyObject *resultobj = 0;
25331 int arg1 = (int) 0 ;
25332 bool arg2 = (bool) true ;
25333 wxIconizeEvent *result = 0 ;
25334 int val1 ;
25335 int ecode1 = 0 ;
25336 bool val2 ;
25337 int ecode2 = 0 ;
25338 PyObject * obj0 = 0 ;
25339 PyObject * obj1 = 0 ;
25340 char * kwnames[] = {
25341 (char *) "id",(char *) "iconized", NULL
25342 };
25343
25344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25345 if (obj0) {
25346 ecode1 = SWIG_AsVal_int(obj0, &val1);
25347 if (!SWIG_IsOK(ecode1)) {
25348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25349 }
25350 arg1 = static_cast< int >(val1);
25351 }
25352 if (obj1) {
25353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25354 if (!SWIG_IsOK(ecode2)) {
25355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25356 }
25357 arg2 = static_cast< bool >(val2);
25358 }
25359 {
25360 PyThreadState* __tstate = wxPyBeginAllowThreads();
25361 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25362 wxPyEndAllowThreads(__tstate);
25363 if (PyErr_Occurred()) SWIG_fail;
25364 }
25365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25366 return resultobj;
25367 fail:
25368 return NULL;
25369 }
25370
25371
25372 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25373 PyObject *resultobj = 0;
25374 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25375 bool result;
25376 void *argp1 = 0 ;
25377 int res1 = 0 ;
25378 PyObject *swig_obj[1] ;
25379
25380 if (!args) SWIG_fail;
25381 swig_obj[0] = args;
25382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25383 if (!SWIG_IsOK(res1)) {
25384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25385 }
25386 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25387 {
25388 PyThreadState* __tstate = wxPyBeginAllowThreads();
25389 result = (bool)(arg1)->Iconized();
25390 wxPyEndAllowThreads(__tstate);
25391 if (PyErr_Occurred()) SWIG_fail;
25392 }
25393 {
25394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25395 }
25396 return resultobj;
25397 fail:
25398 return NULL;
25399 }
25400
25401
25402 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25403 PyObject *obj;
25404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25405 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25406 return SWIG_Py_Void();
25407 }
25408
25409 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25410 return SWIG_Python_InitShadowInstance(args);
25411 }
25412
25413 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj = 0;
25415 int arg1 = (int) 0 ;
25416 wxMaximizeEvent *result = 0 ;
25417 int val1 ;
25418 int ecode1 = 0 ;
25419 PyObject * obj0 = 0 ;
25420 char * kwnames[] = {
25421 (char *) "id", NULL
25422 };
25423
25424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25425 if (obj0) {
25426 ecode1 = SWIG_AsVal_int(obj0, &val1);
25427 if (!SWIG_IsOK(ecode1)) {
25428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25429 }
25430 arg1 = static_cast< int >(val1);
25431 }
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25439 return resultobj;
25440 fail:
25441 return NULL;
25442 }
25443
25444
25445 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25446 PyObject *obj;
25447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25448 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25449 return SWIG_Py_Void();
25450 }
25451
25452 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25453 return SWIG_Python_InitShadowInstance(args);
25454 }
25455
25456 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25457 PyObject *resultobj = 0;
25458 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25459 wxPoint result;
25460 void *argp1 = 0 ;
25461 int res1 = 0 ;
25462 PyObject *swig_obj[1] ;
25463
25464 if (!args) SWIG_fail;
25465 swig_obj[0] = args;
25466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25467 if (!SWIG_IsOK(res1)) {
25468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25469 }
25470 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25471 {
25472 PyThreadState* __tstate = wxPyBeginAllowThreads();
25473 result = (arg1)->GetPosition();
25474 wxPyEndAllowThreads(__tstate);
25475 if (PyErr_Occurred()) SWIG_fail;
25476 }
25477 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25478 return resultobj;
25479 fail:
25480 return NULL;
25481 }
25482
25483
25484 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25485 PyObject *resultobj = 0;
25486 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25487 int result;
25488 void *argp1 = 0 ;
25489 int res1 = 0 ;
25490 PyObject *swig_obj[1] ;
25491
25492 if (!args) SWIG_fail;
25493 swig_obj[0] = args;
25494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25495 if (!SWIG_IsOK(res1)) {
25496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25497 }
25498 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25499 {
25500 PyThreadState* __tstate = wxPyBeginAllowThreads();
25501 result = (int)(arg1)->GetNumberOfFiles();
25502 wxPyEndAllowThreads(__tstate);
25503 if (PyErr_Occurred()) SWIG_fail;
25504 }
25505 resultobj = SWIG_From_int(static_cast< int >(result));
25506 return resultobj;
25507 fail:
25508 return NULL;
25509 }
25510
25511
25512 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25513 PyObject *resultobj = 0;
25514 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25515 PyObject *result = 0 ;
25516 void *argp1 = 0 ;
25517 int res1 = 0 ;
25518 PyObject *swig_obj[1] ;
25519
25520 if (!args) SWIG_fail;
25521 swig_obj[0] = args;
25522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25523 if (!SWIG_IsOK(res1)) {
25524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25525 }
25526 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25530 wxPyEndAllowThreads(__tstate);
25531 if (PyErr_Occurred()) SWIG_fail;
25532 }
25533 resultobj = result;
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *obj;
25542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25543 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25544 return SWIG_Py_Void();
25545 }
25546
25547 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25548 PyObject *resultobj = 0;
25549 int arg1 = (int) 0 ;
25550 wxUpdateUIEvent *result = 0 ;
25551 int val1 ;
25552 int ecode1 = 0 ;
25553 PyObject * obj0 = 0 ;
25554 char * kwnames[] = {
25555 (char *) "commandId", NULL
25556 };
25557
25558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25559 if (obj0) {
25560 ecode1 = SWIG_AsVal_int(obj0, &val1);
25561 if (!SWIG_IsOK(ecode1)) {
25562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25563 }
25564 arg1 = static_cast< int >(val1);
25565 }
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25569 wxPyEndAllowThreads(__tstate);
25570 if (PyErr_Occurred()) SWIG_fail;
25571 }
25572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 PyObject *resultobj = 0;
25581 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25582 bool result;
25583 void *argp1 = 0 ;
25584 int res1 = 0 ;
25585 PyObject *swig_obj[1] ;
25586
25587 if (!args) SWIG_fail;
25588 swig_obj[0] = args;
25589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25590 if (!SWIG_IsOK(res1)) {
25591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25592 }
25593 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25597 wxPyEndAllowThreads(__tstate);
25598 if (PyErr_Occurred()) SWIG_fail;
25599 }
25600 {
25601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25602 }
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25610 PyObject *resultobj = 0;
25611 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25612 bool result;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 PyObject *swig_obj[1] ;
25616
25617 if (!args) SWIG_fail;
25618 swig_obj[0] = args;
25619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25620 if (!SWIG_IsOK(res1)) {
25621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25622 }
25623 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 {
25631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25632 }
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25640 PyObject *resultobj = 0;
25641 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25642 bool result;
25643 void *argp1 = 0 ;
25644 int res1 = 0 ;
25645 PyObject *swig_obj[1] ;
25646
25647 if (!args) SWIG_fail;
25648 swig_obj[0] = args;
25649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25650 if (!SWIG_IsOK(res1)) {
25651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25652 }
25653 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25657 wxPyEndAllowThreads(__tstate);
25658 if (PyErr_Occurred()) SWIG_fail;
25659 }
25660 {
25661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25662 }
25663 return resultobj;
25664 fail:
25665 return NULL;
25666 }
25667
25668
25669 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25670 PyObject *resultobj = 0;
25671 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25672 wxString result;
25673 void *argp1 = 0 ;
25674 int res1 = 0 ;
25675 PyObject *swig_obj[1] ;
25676
25677 if (!args) SWIG_fail;
25678 swig_obj[0] = args;
25679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25680 if (!SWIG_IsOK(res1)) {
25681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25682 }
25683 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25684 {
25685 PyThreadState* __tstate = wxPyBeginAllowThreads();
25686 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25687 wxPyEndAllowThreads(__tstate);
25688 if (PyErr_Occurred()) SWIG_fail;
25689 }
25690 {
25691 #if wxUSE_UNICODE
25692 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25693 #else
25694 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25695 #endif
25696 }
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25704 PyObject *resultobj = 0;
25705 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25706 bool result;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 PyObject *swig_obj[1] ;
25710
25711 if (!args) SWIG_fail;
25712 swig_obj[0] = args;
25713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25714 if (!SWIG_IsOK(res1)) {
25715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25716 }
25717 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25718 {
25719 PyThreadState* __tstate = wxPyBeginAllowThreads();
25720 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25721 wxPyEndAllowThreads(__tstate);
25722 if (PyErr_Occurred()) SWIG_fail;
25723 }
25724 {
25725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25726 }
25727 return resultobj;
25728 fail:
25729 return NULL;
25730 }
25731
25732
25733 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25734 PyObject *resultobj = 0;
25735 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25736 bool result;
25737 void *argp1 = 0 ;
25738 int res1 = 0 ;
25739 PyObject *swig_obj[1] ;
25740
25741 if (!args) SWIG_fail;
25742 swig_obj[0] = args;
25743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25744 if (!SWIG_IsOK(res1)) {
25745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25746 }
25747 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25748 {
25749 PyThreadState* __tstate = wxPyBeginAllowThreads();
25750 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25751 wxPyEndAllowThreads(__tstate);
25752 if (PyErr_Occurred()) SWIG_fail;
25753 }
25754 {
25755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25756 }
25757 return resultobj;
25758 fail:
25759 return NULL;
25760 }
25761
25762
25763 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25764 PyObject *resultobj = 0;
25765 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25766 bool result;
25767 void *argp1 = 0 ;
25768 int res1 = 0 ;
25769 PyObject *swig_obj[1] ;
25770
25771 if (!args) SWIG_fail;
25772 swig_obj[0] = args;
25773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25774 if (!SWIG_IsOK(res1)) {
25775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25776 }
25777 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25778 {
25779 PyThreadState* __tstate = wxPyBeginAllowThreads();
25780 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25781 wxPyEndAllowThreads(__tstate);
25782 if (PyErr_Occurred()) SWIG_fail;
25783 }
25784 {
25785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25786 }
25787 return resultobj;
25788 fail:
25789 return NULL;
25790 }
25791
25792
25793 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25794 PyObject *resultobj = 0;
25795 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25796 bool result;
25797 void *argp1 = 0 ;
25798 int res1 = 0 ;
25799 PyObject *swig_obj[1] ;
25800
25801 if (!args) SWIG_fail;
25802 swig_obj[0] = args;
25803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25804 if (!SWIG_IsOK(res1)) {
25805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25806 }
25807 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25808 {
25809 PyThreadState* __tstate = wxPyBeginAllowThreads();
25810 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 {
25815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25816 }
25817 return resultobj;
25818 fail:
25819 return NULL;
25820 }
25821
25822
25823 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25824 PyObject *resultobj = 0;
25825 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25826 bool arg2 ;
25827 void *argp1 = 0 ;
25828 int res1 = 0 ;
25829 bool val2 ;
25830 int ecode2 = 0 ;
25831 PyObject * obj0 = 0 ;
25832 PyObject * obj1 = 0 ;
25833 char * kwnames[] = {
25834 (char *) "self",(char *) "check", NULL
25835 };
25836
25837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25839 if (!SWIG_IsOK(res1)) {
25840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25841 }
25842 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25843 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25844 if (!SWIG_IsOK(ecode2)) {
25845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25846 }
25847 arg2 = static_cast< bool >(val2);
25848 {
25849 PyThreadState* __tstate = wxPyBeginAllowThreads();
25850 (arg1)->Check(arg2);
25851 wxPyEndAllowThreads(__tstate);
25852 if (PyErr_Occurred()) SWIG_fail;
25853 }
25854 resultobj = SWIG_Py_Void();
25855 return resultobj;
25856 fail:
25857 return NULL;
25858 }
25859
25860
25861 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25862 PyObject *resultobj = 0;
25863 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25864 bool arg2 ;
25865 void *argp1 = 0 ;
25866 int res1 = 0 ;
25867 bool val2 ;
25868 int ecode2 = 0 ;
25869 PyObject * obj0 = 0 ;
25870 PyObject * obj1 = 0 ;
25871 char * kwnames[] = {
25872 (char *) "self",(char *) "enable", NULL
25873 };
25874
25875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25877 if (!SWIG_IsOK(res1)) {
25878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25879 }
25880 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25881 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25882 if (!SWIG_IsOK(ecode2)) {
25883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25884 }
25885 arg2 = static_cast< bool >(val2);
25886 {
25887 PyThreadState* __tstate = wxPyBeginAllowThreads();
25888 (arg1)->Enable(arg2);
25889 wxPyEndAllowThreads(__tstate);
25890 if (PyErr_Occurred()) SWIG_fail;
25891 }
25892 resultobj = SWIG_Py_Void();
25893 return resultobj;
25894 fail:
25895 return NULL;
25896 }
25897
25898
25899 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25900 PyObject *resultobj = 0;
25901 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25902 bool arg2 ;
25903 void *argp1 = 0 ;
25904 int res1 = 0 ;
25905 bool val2 ;
25906 int ecode2 = 0 ;
25907 PyObject * obj0 = 0 ;
25908 PyObject * obj1 = 0 ;
25909 char * kwnames[] = {
25910 (char *) "self",(char *) "show", NULL
25911 };
25912
25913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25915 if (!SWIG_IsOK(res1)) {
25916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25917 }
25918 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25920 if (!SWIG_IsOK(ecode2)) {
25921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25922 }
25923 arg2 = static_cast< bool >(val2);
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 (arg1)->Show(arg2);
25927 wxPyEndAllowThreads(__tstate);
25928 if (PyErr_Occurred()) SWIG_fail;
25929 }
25930 resultobj = SWIG_Py_Void();
25931 return resultobj;
25932 fail:
25933 return NULL;
25934 }
25935
25936
25937 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25938 PyObject *resultobj = 0;
25939 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25940 wxString *arg2 = 0 ;
25941 void *argp1 = 0 ;
25942 int res1 = 0 ;
25943 bool temp2 = false ;
25944 PyObject * obj0 = 0 ;
25945 PyObject * obj1 = 0 ;
25946 char * kwnames[] = {
25947 (char *) "self",(char *) "text", NULL
25948 };
25949
25950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25952 if (!SWIG_IsOK(res1)) {
25953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25954 }
25955 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25956 {
25957 arg2 = wxString_in_helper(obj1);
25958 if (arg2 == NULL) SWIG_fail;
25959 temp2 = true;
25960 }
25961 {
25962 PyThreadState* __tstate = wxPyBeginAllowThreads();
25963 (arg1)->SetText((wxString const &)*arg2);
25964 wxPyEndAllowThreads(__tstate);
25965 if (PyErr_Occurred()) SWIG_fail;
25966 }
25967 resultobj = SWIG_Py_Void();
25968 {
25969 if (temp2)
25970 delete arg2;
25971 }
25972 return resultobj;
25973 fail:
25974 {
25975 if (temp2)
25976 delete arg2;
25977 }
25978 return NULL;
25979 }
25980
25981
25982 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25983 PyObject *resultobj = 0;
25984 long arg1 ;
25985 long val1 ;
25986 int ecode1 = 0 ;
25987 PyObject * obj0 = 0 ;
25988 char * kwnames[] = {
25989 (char *) "updateInterval", NULL
25990 };
25991
25992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25993 ecode1 = SWIG_AsVal_long(obj0, &val1);
25994 if (!SWIG_IsOK(ecode1)) {
25995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25996 }
25997 arg1 = static_cast< long >(val1);
25998 {
25999 PyThreadState* __tstate = wxPyBeginAllowThreads();
26000 wxUpdateUIEvent::SetUpdateInterval(arg1);
26001 wxPyEndAllowThreads(__tstate);
26002 if (PyErr_Occurred()) SWIG_fail;
26003 }
26004 resultobj = SWIG_Py_Void();
26005 return resultobj;
26006 fail:
26007 return NULL;
26008 }
26009
26010
26011 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26012 PyObject *resultobj = 0;
26013 long result;
26014
26015 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
26016 {
26017 PyThreadState* __tstate = wxPyBeginAllowThreads();
26018 result = (long)wxUpdateUIEvent::GetUpdateInterval();
26019 wxPyEndAllowThreads(__tstate);
26020 if (PyErr_Occurred()) SWIG_fail;
26021 }
26022 resultobj = SWIG_From_long(static_cast< long >(result));
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26030 PyObject *resultobj = 0;
26031 wxWindow *arg1 = (wxWindow *) 0 ;
26032 bool result;
26033 void *argp1 = 0 ;
26034 int res1 = 0 ;
26035 PyObject * obj0 = 0 ;
26036 char * kwnames[] = {
26037 (char *) "win", NULL
26038 };
26039
26040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
26041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
26044 }
26045 arg1 = reinterpret_cast< wxWindow * >(argp1);
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 {
26053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26054 }
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26062 PyObject *resultobj = 0;
26063
26064 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
26065 {
26066 PyThreadState* __tstate = wxPyBeginAllowThreads();
26067 wxUpdateUIEvent::ResetUpdateTime();
26068 wxPyEndAllowThreads(__tstate);
26069 if (PyErr_Occurred()) SWIG_fail;
26070 }
26071 resultobj = SWIG_Py_Void();
26072 return resultobj;
26073 fail:
26074 return NULL;
26075 }
26076
26077
26078 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26079 PyObject *resultobj = 0;
26080 wxUpdateUIMode arg1 ;
26081 int val1 ;
26082 int ecode1 = 0 ;
26083 PyObject * obj0 = 0 ;
26084 char * kwnames[] = {
26085 (char *) "mode", NULL
26086 };
26087
26088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26089 ecode1 = SWIG_AsVal_int(obj0, &val1);
26090 if (!SWIG_IsOK(ecode1)) {
26091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
26092 }
26093 arg1 = static_cast< wxUpdateUIMode >(val1);
26094 {
26095 PyThreadState* __tstate = wxPyBeginAllowThreads();
26096 wxUpdateUIEvent::SetMode(arg1);
26097 wxPyEndAllowThreads(__tstate);
26098 if (PyErr_Occurred()) SWIG_fail;
26099 }
26100 resultobj = SWIG_Py_Void();
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *resultobj = 0;
26109 wxUpdateUIMode result;
26110
26111 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_From_int(static_cast< int >(result));
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26126 PyObject *obj;
26127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26128 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26129 return SWIG_Py_Void();
26130 }
26131
26132 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26133 return SWIG_Python_InitShadowInstance(args);
26134 }
26135
26136 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26137 PyObject *resultobj = 0;
26138 wxSysColourChangedEvent *result = 0 ;
26139
26140 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26141 {
26142 PyThreadState* __tstate = wxPyBeginAllowThreads();
26143 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26144 wxPyEndAllowThreads(__tstate);
26145 if (PyErr_Occurred()) SWIG_fail;
26146 }
26147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26148 return resultobj;
26149 fail:
26150 return NULL;
26151 }
26152
26153
26154 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26155 PyObject *obj;
26156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26157 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26158 return SWIG_Py_Void();
26159 }
26160
26161 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26162 return SWIG_Python_InitShadowInstance(args);
26163 }
26164
26165 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26166 PyObject *resultobj = 0;
26167 int arg1 = (int) 0 ;
26168 wxWindow *arg2 = (wxWindow *) NULL ;
26169 wxMouseCaptureChangedEvent *result = 0 ;
26170 int val1 ;
26171 int ecode1 = 0 ;
26172 void *argp2 = 0 ;
26173 int res2 = 0 ;
26174 PyObject * obj0 = 0 ;
26175 PyObject * obj1 = 0 ;
26176 char * kwnames[] = {
26177 (char *) "winid",(char *) "gainedCapture", NULL
26178 };
26179
26180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26181 if (obj0) {
26182 ecode1 = SWIG_AsVal_int(obj0, &val1);
26183 if (!SWIG_IsOK(ecode1)) {
26184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26185 }
26186 arg1 = static_cast< int >(val1);
26187 }
26188 if (obj1) {
26189 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26190 if (!SWIG_IsOK(res2)) {
26191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26192 }
26193 arg2 = reinterpret_cast< wxWindow * >(argp2);
26194 }
26195 {
26196 PyThreadState* __tstate = wxPyBeginAllowThreads();
26197 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26198 wxPyEndAllowThreads(__tstate);
26199 if (PyErr_Occurred()) SWIG_fail;
26200 }
26201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26209 PyObject *resultobj = 0;
26210 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26211 wxWindow *result = 0 ;
26212 void *argp1 = 0 ;
26213 int res1 = 0 ;
26214 PyObject *swig_obj[1] ;
26215
26216 if (!args) SWIG_fail;
26217 swig_obj[0] = args;
26218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26219 if (!SWIG_IsOK(res1)) {
26220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26221 }
26222 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26223 {
26224 PyThreadState* __tstate = wxPyBeginAllowThreads();
26225 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26226 wxPyEndAllowThreads(__tstate);
26227 if (PyErr_Occurred()) SWIG_fail;
26228 }
26229 {
26230 resultobj = wxPyMake_wxObject(result, (bool)0);
26231 }
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26239 PyObject *obj;
26240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26241 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26242 return SWIG_Py_Void();
26243 }
26244
26245 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26246 return SWIG_Python_InitShadowInstance(args);
26247 }
26248
26249 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj = 0;
26251 int arg1 = (int) 0 ;
26252 wxMouseCaptureLostEvent *result = 0 ;
26253 int val1 ;
26254 int ecode1 = 0 ;
26255 PyObject * obj0 = 0 ;
26256 char * kwnames[] = {
26257 (char *) "winid", NULL
26258 };
26259
26260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26261 if (obj0) {
26262 ecode1 = SWIG_AsVal_int(obj0, &val1);
26263 if (!SWIG_IsOK(ecode1)) {
26264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26265 }
26266 arg1 = static_cast< int >(val1);
26267 }
26268 {
26269 PyThreadState* __tstate = wxPyBeginAllowThreads();
26270 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26282 PyObject *obj;
26283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26284 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26285 return SWIG_Py_Void();
26286 }
26287
26288 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26289 return SWIG_Python_InitShadowInstance(args);
26290 }
26291
26292 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26293 PyObject *resultobj = 0;
26294 wxDisplayChangedEvent *result = 0 ;
26295
26296 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26297 {
26298 PyThreadState* __tstate = wxPyBeginAllowThreads();
26299 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26300 wxPyEndAllowThreads(__tstate);
26301 if (PyErr_Occurred()) SWIG_fail;
26302 }
26303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26311 PyObject *obj;
26312 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26313 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26314 return SWIG_Py_Void();
26315 }
26316
26317 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26318 return SWIG_Python_InitShadowInstance(args);
26319 }
26320
26321 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26322 PyObject *resultobj = 0;
26323 int arg1 = (int) 0 ;
26324 wxPaletteChangedEvent *result = 0 ;
26325 int val1 ;
26326 int ecode1 = 0 ;
26327 PyObject * obj0 = 0 ;
26328 char * kwnames[] = {
26329 (char *) "id", NULL
26330 };
26331
26332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26333 if (obj0) {
26334 ecode1 = SWIG_AsVal_int(obj0, &val1);
26335 if (!SWIG_IsOK(ecode1)) {
26336 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26337 }
26338 arg1 = static_cast< int >(val1);
26339 }
26340 {
26341 PyThreadState* __tstate = wxPyBeginAllowThreads();
26342 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26343 wxPyEndAllowThreads(__tstate);
26344 if (PyErr_Occurred()) SWIG_fail;
26345 }
26346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26354 PyObject *resultobj = 0;
26355 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26356 wxWindow *arg2 = (wxWindow *) 0 ;
26357 void *argp1 = 0 ;
26358 int res1 = 0 ;
26359 void *argp2 = 0 ;
26360 int res2 = 0 ;
26361 PyObject * obj0 = 0 ;
26362 PyObject * obj1 = 0 ;
26363 char * kwnames[] = {
26364 (char *) "self",(char *) "win", NULL
26365 };
26366
26367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26369 if (!SWIG_IsOK(res1)) {
26370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26371 }
26372 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26374 if (!SWIG_IsOK(res2)) {
26375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26376 }
26377 arg2 = reinterpret_cast< wxWindow * >(argp2);
26378 {
26379 PyThreadState* __tstate = wxPyBeginAllowThreads();
26380 (arg1)->SetChangedWindow(arg2);
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 resultobj = SWIG_Py_Void();
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26392 PyObject *resultobj = 0;
26393 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26394 wxWindow *result = 0 ;
26395 void *argp1 = 0 ;
26396 int res1 = 0 ;
26397 PyObject *swig_obj[1] ;
26398
26399 if (!args) SWIG_fail;
26400 swig_obj[0] = args;
26401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26402 if (!SWIG_IsOK(res1)) {
26403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26404 }
26405 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26406 {
26407 PyThreadState* __tstate = wxPyBeginAllowThreads();
26408 result = (wxWindow *)(arg1)->GetChangedWindow();
26409 wxPyEndAllowThreads(__tstate);
26410 if (PyErr_Occurred()) SWIG_fail;
26411 }
26412 {
26413 resultobj = wxPyMake_wxObject(result, (bool)0);
26414 }
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422 PyObject *obj;
26423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26424 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26425 return SWIG_Py_Void();
26426 }
26427
26428 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26429 return SWIG_Python_InitShadowInstance(args);
26430 }
26431
26432 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26433 PyObject *resultobj = 0;
26434 int arg1 = (int) 0 ;
26435 wxQueryNewPaletteEvent *result = 0 ;
26436 int val1 ;
26437 int ecode1 = 0 ;
26438 PyObject * obj0 = 0 ;
26439 char * kwnames[] = {
26440 (char *) "winid", NULL
26441 };
26442
26443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26444 if (obj0) {
26445 ecode1 = SWIG_AsVal_int(obj0, &val1);
26446 if (!SWIG_IsOK(ecode1)) {
26447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26448 }
26449 arg1 = static_cast< int >(val1);
26450 }
26451 {
26452 PyThreadState* __tstate = wxPyBeginAllowThreads();
26453 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26458 return resultobj;
26459 fail:
26460 return NULL;
26461 }
26462
26463
26464 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26465 PyObject *resultobj = 0;
26466 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26467 bool arg2 ;
26468 void *argp1 = 0 ;
26469 int res1 = 0 ;
26470 bool val2 ;
26471 int ecode2 = 0 ;
26472 PyObject * obj0 = 0 ;
26473 PyObject * obj1 = 0 ;
26474 char * kwnames[] = {
26475 (char *) "self",(char *) "realized", NULL
26476 };
26477
26478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26480 if (!SWIG_IsOK(res1)) {
26481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26482 }
26483 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26484 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26485 if (!SWIG_IsOK(ecode2)) {
26486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26487 }
26488 arg2 = static_cast< bool >(val2);
26489 {
26490 PyThreadState* __tstate = wxPyBeginAllowThreads();
26491 (arg1)->SetPaletteRealized(arg2);
26492 wxPyEndAllowThreads(__tstate);
26493 if (PyErr_Occurred()) SWIG_fail;
26494 }
26495 resultobj = SWIG_Py_Void();
26496 return resultobj;
26497 fail:
26498 return NULL;
26499 }
26500
26501
26502 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26503 PyObject *resultobj = 0;
26504 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26505 bool result;
26506 void *argp1 = 0 ;
26507 int res1 = 0 ;
26508 PyObject *swig_obj[1] ;
26509
26510 if (!args) SWIG_fail;
26511 swig_obj[0] = args;
26512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26513 if (!SWIG_IsOK(res1)) {
26514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26515 }
26516 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26517 {
26518 PyThreadState* __tstate = wxPyBeginAllowThreads();
26519 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 {
26524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26525 }
26526 return resultobj;
26527 fail:
26528 return NULL;
26529 }
26530
26531
26532 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26533 PyObject *obj;
26534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26535 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26536 return SWIG_Py_Void();
26537 }
26538
26539 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26540 return SWIG_Python_InitShadowInstance(args);
26541 }
26542
26543 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26544 PyObject *resultobj = 0;
26545 wxNavigationKeyEvent *result = 0 ;
26546
26547 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26548 {
26549 PyThreadState* __tstate = wxPyBeginAllowThreads();
26550 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26551 wxPyEndAllowThreads(__tstate);
26552 if (PyErr_Occurred()) SWIG_fail;
26553 }
26554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26555 return resultobj;
26556 fail:
26557 return NULL;
26558 }
26559
26560
26561 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26562 PyObject *resultobj = 0;
26563 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26564 bool result;
26565 void *argp1 = 0 ;
26566 int res1 = 0 ;
26567 PyObject *swig_obj[1] ;
26568
26569 if (!args) SWIG_fail;
26570 swig_obj[0] = args;
26571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26572 if (!SWIG_IsOK(res1)) {
26573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26574 }
26575 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26576 {
26577 PyThreadState* __tstate = wxPyBeginAllowThreads();
26578 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26579 wxPyEndAllowThreads(__tstate);
26580 if (PyErr_Occurred()) SWIG_fail;
26581 }
26582 {
26583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26584 }
26585 return resultobj;
26586 fail:
26587 return NULL;
26588 }
26589
26590
26591 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26592 PyObject *resultobj = 0;
26593 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26594 bool arg2 ;
26595 void *argp1 = 0 ;
26596 int res1 = 0 ;
26597 bool val2 ;
26598 int ecode2 = 0 ;
26599 PyObject * obj0 = 0 ;
26600 PyObject * obj1 = 0 ;
26601 char * kwnames[] = {
26602 (char *) "self",(char *) "forward", NULL
26603 };
26604
26605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26607 if (!SWIG_IsOK(res1)) {
26608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26609 }
26610 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26611 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26612 if (!SWIG_IsOK(ecode2)) {
26613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26614 }
26615 arg2 = static_cast< bool >(val2);
26616 {
26617 PyThreadState* __tstate = wxPyBeginAllowThreads();
26618 (arg1)->SetDirection(arg2);
26619 wxPyEndAllowThreads(__tstate);
26620 if (PyErr_Occurred()) SWIG_fail;
26621 }
26622 resultobj = SWIG_Py_Void();
26623 return resultobj;
26624 fail:
26625 return NULL;
26626 }
26627
26628
26629 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26630 PyObject *resultobj = 0;
26631 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26632 bool result;
26633 void *argp1 = 0 ;
26634 int res1 = 0 ;
26635 PyObject *swig_obj[1] ;
26636
26637 if (!args) SWIG_fail;
26638 swig_obj[0] = args;
26639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26640 if (!SWIG_IsOK(res1)) {
26641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26642 }
26643 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26644 {
26645 PyThreadState* __tstate = wxPyBeginAllowThreads();
26646 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26647 wxPyEndAllowThreads(__tstate);
26648 if (PyErr_Occurred()) SWIG_fail;
26649 }
26650 {
26651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26652 }
26653 return resultobj;
26654 fail:
26655 return NULL;
26656 }
26657
26658
26659 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj = 0;
26661 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26662 bool arg2 ;
26663 void *argp1 = 0 ;
26664 int res1 = 0 ;
26665 bool val2 ;
26666 int ecode2 = 0 ;
26667 PyObject * obj0 = 0 ;
26668 PyObject * obj1 = 0 ;
26669 char * kwnames[] = {
26670 (char *) "self",(char *) "ischange", NULL
26671 };
26672
26673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26675 if (!SWIG_IsOK(res1)) {
26676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26677 }
26678 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26679 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26680 if (!SWIG_IsOK(ecode2)) {
26681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26682 }
26683 arg2 = static_cast< bool >(val2);
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 (arg1)->SetWindowChange(arg2);
26687 wxPyEndAllowThreads(__tstate);
26688 if (PyErr_Occurred()) SWIG_fail;
26689 }
26690 resultobj = SWIG_Py_Void();
26691 return resultobj;
26692 fail:
26693 return NULL;
26694 }
26695
26696
26697 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26698 PyObject *resultobj = 0;
26699 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26700 bool result;
26701 void *argp1 = 0 ;
26702 int res1 = 0 ;
26703 PyObject *swig_obj[1] ;
26704
26705 if (!args) SWIG_fail;
26706 swig_obj[0] = args;
26707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26708 if (!SWIG_IsOK(res1)) {
26709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26710 }
26711 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26712 {
26713 PyThreadState* __tstate = wxPyBeginAllowThreads();
26714 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26715 wxPyEndAllowThreads(__tstate);
26716 if (PyErr_Occurred()) SWIG_fail;
26717 }
26718 {
26719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26720 }
26721 return resultobj;
26722 fail:
26723 return NULL;
26724 }
26725
26726
26727 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26728 PyObject *resultobj = 0;
26729 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26730 bool arg2 ;
26731 void *argp1 = 0 ;
26732 int res1 = 0 ;
26733 bool val2 ;
26734 int ecode2 = 0 ;
26735 PyObject * obj0 = 0 ;
26736 PyObject * obj1 = 0 ;
26737 char * kwnames[] = {
26738 (char *) "self",(char *) "bIs", NULL
26739 };
26740
26741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26743 if (!SWIG_IsOK(res1)) {
26744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26745 }
26746 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26747 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26748 if (!SWIG_IsOK(ecode2)) {
26749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26750 }
26751 arg2 = static_cast< bool >(val2);
26752 {
26753 PyThreadState* __tstate = wxPyBeginAllowThreads();
26754 (arg1)->SetFromTab(arg2);
26755 wxPyEndAllowThreads(__tstate);
26756 if (PyErr_Occurred()) SWIG_fail;
26757 }
26758 resultobj = SWIG_Py_Void();
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj = 0;
26767 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26768 long arg2 ;
26769 void *argp1 = 0 ;
26770 int res1 = 0 ;
26771 long val2 ;
26772 int ecode2 = 0 ;
26773 PyObject * obj0 = 0 ;
26774 PyObject * obj1 = 0 ;
26775 char * kwnames[] = {
26776 (char *) "self",(char *) "flags", NULL
26777 };
26778
26779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26781 if (!SWIG_IsOK(res1)) {
26782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26783 }
26784 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26785 ecode2 = SWIG_AsVal_long(obj1, &val2);
26786 if (!SWIG_IsOK(ecode2)) {
26787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26788 }
26789 arg2 = static_cast< long >(val2);
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 (arg1)->SetFlags(arg2);
26793 wxPyEndAllowThreads(__tstate);
26794 if (PyErr_Occurred()) SWIG_fail;
26795 }
26796 resultobj = SWIG_Py_Void();
26797 return resultobj;
26798 fail:
26799 return NULL;
26800 }
26801
26802
26803 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26804 PyObject *resultobj = 0;
26805 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26806 wxWindow *result = 0 ;
26807 void *argp1 = 0 ;
26808 int res1 = 0 ;
26809 PyObject *swig_obj[1] ;
26810
26811 if (!args) SWIG_fail;
26812 swig_obj[0] = args;
26813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26814 if (!SWIG_IsOK(res1)) {
26815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26816 }
26817 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26818 {
26819 PyThreadState* __tstate = wxPyBeginAllowThreads();
26820 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26821 wxPyEndAllowThreads(__tstate);
26822 if (PyErr_Occurred()) SWIG_fail;
26823 }
26824 {
26825 resultobj = wxPyMake_wxObject(result, (bool)0);
26826 }
26827 return resultobj;
26828 fail:
26829 return NULL;
26830 }
26831
26832
26833 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26834 PyObject *resultobj = 0;
26835 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26836 wxWindow *arg2 = (wxWindow *) 0 ;
26837 void *argp1 = 0 ;
26838 int res1 = 0 ;
26839 void *argp2 = 0 ;
26840 int res2 = 0 ;
26841 PyObject * obj0 = 0 ;
26842 PyObject * obj1 = 0 ;
26843 char * kwnames[] = {
26844 (char *) "self",(char *) "win", NULL
26845 };
26846
26847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26849 if (!SWIG_IsOK(res1)) {
26850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26851 }
26852 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26853 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26854 if (!SWIG_IsOK(res2)) {
26855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26856 }
26857 arg2 = reinterpret_cast< wxWindow * >(argp2);
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 (arg1)->SetCurrentFocus(arg2);
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_Py_Void();
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 PyObject *obj;
26873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26874 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26875 return SWIG_Py_Void();
26876 }
26877
26878 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26879 return SWIG_Python_InitShadowInstance(args);
26880 }
26881
26882 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26883 PyObject *resultobj = 0;
26884 wxWindow *arg1 = (wxWindow *) NULL ;
26885 wxWindowCreateEvent *result = 0 ;
26886 void *argp1 = 0 ;
26887 int res1 = 0 ;
26888 PyObject * obj0 = 0 ;
26889 char * kwnames[] = {
26890 (char *) "win", NULL
26891 };
26892
26893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26894 if (obj0) {
26895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26896 if (!SWIG_IsOK(res1)) {
26897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26898 }
26899 arg1 = reinterpret_cast< wxWindow * >(argp1);
26900 }
26901 {
26902 PyThreadState* __tstate = wxPyBeginAllowThreads();
26903 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26904 wxPyEndAllowThreads(__tstate);
26905 if (PyErr_Occurred()) SWIG_fail;
26906 }
26907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26908 return resultobj;
26909 fail:
26910 return NULL;
26911 }
26912
26913
26914 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26915 PyObject *resultobj = 0;
26916 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26917 wxWindow *result = 0 ;
26918 void *argp1 = 0 ;
26919 int res1 = 0 ;
26920 PyObject *swig_obj[1] ;
26921
26922 if (!args) SWIG_fail;
26923 swig_obj[0] = args;
26924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26925 if (!SWIG_IsOK(res1)) {
26926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26927 }
26928 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26932 wxPyEndAllowThreads(__tstate);
26933 if (PyErr_Occurred()) SWIG_fail;
26934 }
26935 {
26936 resultobj = wxPyMake_wxObject(result, (bool)0);
26937 }
26938 return resultobj;
26939 fail:
26940 return NULL;
26941 }
26942
26943
26944 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26945 PyObject *obj;
26946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26947 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26948 return SWIG_Py_Void();
26949 }
26950
26951 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26952 return SWIG_Python_InitShadowInstance(args);
26953 }
26954
26955 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26956 PyObject *resultobj = 0;
26957 wxWindow *arg1 = (wxWindow *) NULL ;
26958 wxWindowDestroyEvent *result = 0 ;
26959 void *argp1 = 0 ;
26960 int res1 = 0 ;
26961 PyObject * obj0 = 0 ;
26962 char * kwnames[] = {
26963 (char *) "win", NULL
26964 };
26965
26966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26967 if (obj0) {
26968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26969 if (!SWIG_IsOK(res1)) {
26970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26971 }
26972 arg1 = reinterpret_cast< wxWindow * >(argp1);
26973 }
26974 {
26975 PyThreadState* __tstate = wxPyBeginAllowThreads();
26976 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26977 wxPyEndAllowThreads(__tstate);
26978 if (PyErr_Occurred()) SWIG_fail;
26979 }
26980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26981 return resultobj;
26982 fail:
26983 return NULL;
26984 }
26985
26986
26987 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26988 PyObject *resultobj = 0;
26989 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26990 wxWindow *result = 0 ;
26991 void *argp1 = 0 ;
26992 int res1 = 0 ;
26993 PyObject *swig_obj[1] ;
26994
26995 if (!args) SWIG_fail;
26996 swig_obj[0] = args;
26997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26998 if (!SWIG_IsOK(res1)) {
26999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
27000 }
27001 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
27002 {
27003 PyThreadState* __tstate = wxPyBeginAllowThreads();
27004 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 {
27009 resultobj = wxPyMake_wxObject(result, (bool)0);
27010 }
27011 return resultobj;
27012 fail:
27013 return NULL;
27014 }
27015
27016
27017 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27018 PyObject *obj;
27019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27020 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
27021 return SWIG_Py_Void();
27022 }
27023
27024 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27025 return SWIG_Python_InitShadowInstance(args);
27026 }
27027
27028 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27029 PyObject *resultobj = 0;
27030 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27031 int arg2 = (int) 0 ;
27032 wxPoint const &arg3_defvalue = wxDefaultPosition ;
27033 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
27034 wxContextMenuEvent *result = 0 ;
27035 int val1 ;
27036 int ecode1 = 0 ;
27037 int val2 ;
27038 int ecode2 = 0 ;
27039 wxPoint temp3 ;
27040 PyObject * obj0 = 0 ;
27041 PyObject * obj1 = 0 ;
27042 PyObject * obj2 = 0 ;
27043 char * kwnames[] = {
27044 (char *) "type",(char *) "winid",(char *) "pt", NULL
27045 };
27046
27047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27048 if (obj0) {
27049 ecode1 = SWIG_AsVal_int(obj0, &val1);
27050 if (!SWIG_IsOK(ecode1)) {
27051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27052 }
27053 arg1 = static_cast< wxEventType >(val1);
27054 }
27055 if (obj1) {
27056 ecode2 = SWIG_AsVal_int(obj1, &val2);
27057 if (!SWIG_IsOK(ecode2)) {
27058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
27059 }
27060 arg2 = static_cast< int >(val2);
27061 }
27062 if (obj2) {
27063 {
27064 arg3 = &temp3;
27065 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27066 }
27067 }
27068 {
27069 PyThreadState* __tstate = wxPyBeginAllowThreads();
27070 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
27071 wxPyEndAllowThreads(__tstate);
27072 if (PyErr_Occurred()) SWIG_fail;
27073 }
27074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
27075 return resultobj;
27076 fail:
27077 return NULL;
27078 }
27079
27080
27081 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27082 PyObject *resultobj = 0;
27083 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27084 wxPoint *result = 0 ;
27085 void *argp1 = 0 ;
27086 int res1 = 0 ;
27087 PyObject *swig_obj[1] ;
27088
27089 if (!args) SWIG_fail;
27090 swig_obj[0] = args;
27091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27092 if (!SWIG_IsOK(res1)) {
27093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
27094 }
27095 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27096 {
27097 PyThreadState* __tstate = wxPyBeginAllowThreads();
27098 {
27099 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
27100 result = (wxPoint *) &_result_ref;
27101 }
27102 wxPyEndAllowThreads(__tstate);
27103 if (PyErr_Occurred()) SWIG_fail;
27104 }
27105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
27106 return resultobj;
27107 fail:
27108 return NULL;
27109 }
27110
27111
27112 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27113 PyObject *resultobj = 0;
27114 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27115 wxPoint *arg2 = 0 ;
27116 void *argp1 = 0 ;
27117 int res1 = 0 ;
27118 wxPoint temp2 ;
27119 PyObject * obj0 = 0 ;
27120 PyObject * obj1 = 0 ;
27121 char * kwnames[] = {
27122 (char *) "self",(char *) "pos", NULL
27123 };
27124
27125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27127 if (!SWIG_IsOK(res1)) {
27128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27129 }
27130 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27131 {
27132 arg2 = &temp2;
27133 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27134 }
27135 {
27136 PyThreadState* __tstate = wxPyBeginAllowThreads();
27137 (arg1)->SetPosition((wxPoint const &)*arg2);
27138 wxPyEndAllowThreads(__tstate);
27139 if (PyErr_Occurred()) SWIG_fail;
27140 }
27141 resultobj = SWIG_Py_Void();
27142 return resultobj;
27143 fail:
27144 return NULL;
27145 }
27146
27147
27148 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27149 PyObject *obj;
27150 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27151 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27152 return SWIG_Py_Void();
27153 }
27154
27155 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27156 return SWIG_Python_InitShadowInstance(args);
27157 }
27158
27159 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27160 PyObject *resultobj = 0;
27161 wxIdleEvent *result = 0 ;
27162
27163 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = (wxIdleEvent *)new wxIdleEvent();
27167 wxPyEndAllowThreads(__tstate);
27168 if (PyErr_Occurred()) SWIG_fail;
27169 }
27170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27171 return resultobj;
27172 fail:
27173 return NULL;
27174 }
27175
27176
27177 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27178 PyObject *resultobj = 0;
27179 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27180 bool arg2 = (bool) true ;
27181 void *argp1 = 0 ;
27182 int res1 = 0 ;
27183 bool val2 ;
27184 int ecode2 = 0 ;
27185 PyObject * obj0 = 0 ;
27186 PyObject * obj1 = 0 ;
27187 char * kwnames[] = {
27188 (char *) "self",(char *) "needMore", NULL
27189 };
27190
27191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27193 if (!SWIG_IsOK(res1)) {
27194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27195 }
27196 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27197 if (obj1) {
27198 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27199 if (!SWIG_IsOK(ecode2)) {
27200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27201 }
27202 arg2 = static_cast< bool >(val2);
27203 }
27204 {
27205 PyThreadState* __tstate = wxPyBeginAllowThreads();
27206 (arg1)->RequestMore(arg2);
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 resultobj = SWIG_Py_Void();
27211 return resultobj;
27212 fail:
27213 return NULL;
27214 }
27215
27216
27217 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27218 PyObject *resultobj = 0;
27219 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27220 bool result;
27221 void *argp1 = 0 ;
27222 int res1 = 0 ;
27223 PyObject *swig_obj[1] ;
27224
27225 if (!args) SWIG_fail;
27226 swig_obj[0] = args;
27227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27228 if (!SWIG_IsOK(res1)) {
27229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27230 }
27231 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27235 wxPyEndAllowThreads(__tstate);
27236 if (PyErr_Occurred()) SWIG_fail;
27237 }
27238 {
27239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27240 }
27241 return resultobj;
27242 fail:
27243 return NULL;
27244 }
27245
27246
27247 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27248 PyObject *resultobj = 0;
27249 wxIdleMode arg1 ;
27250 int val1 ;
27251 int ecode1 = 0 ;
27252 PyObject * obj0 = 0 ;
27253 char * kwnames[] = {
27254 (char *) "mode", NULL
27255 };
27256
27257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27258 ecode1 = SWIG_AsVal_int(obj0, &val1);
27259 if (!SWIG_IsOK(ecode1)) {
27260 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27261 }
27262 arg1 = static_cast< wxIdleMode >(val1);
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 wxIdleEvent::SetMode(arg1);
27266 wxPyEndAllowThreads(__tstate);
27267 if (PyErr_Occurred()) SWIG_fail;
27268 }
27269 resultobj = SWIG_Py_Void();
27270 return resultobj;
27271 fail:
27272 return NULL;
27273 }
27274
27275
27276 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27277 PyObject *resultobj = 0;
27278 wxIdleMode result;
27279
27280 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27281 {
27282 PyThreadState* __tstate = wxPyBeginAllowThreads();
27283 result = (wxIdleMode)wxIdleEvent::GetMode();
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 resultobj = SWIG_From_int(static_cast< int >(result));
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27295 PyObject *resultobj = 0;
27296 wxWindow *arg1 = (wxWindow *) 0 ;
27297 bool result;
27298 void *argp1 = 0 ;
27299 int res1 = 0 ;
27300 PyObject * obj0 = 0 ;
27301 char * kwnames[] = {
27302 (char *) "win", NULL
27303 };
27304
27305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27307 if (!SWIG_IsOK(res1)) {
27308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27309 }
27310 arg1 = reinterpret_cast< wxWindow * >(argp1);
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 result = (bool)wxIdleEvent::CanSend(arg1);
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 {
27318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27319 }
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27327 PyObject *obj;
27328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27329 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27330 return SWIG_Py_Void();
27331 }
27332
27333 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27334 return SWIG_Python_InitShadowInstance(args);
27335 }
27336
27337 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27338 PyObject *resultobj = 0;
27339 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27340 int arg2 = (int) 0 ;
27341 wxClipboardTextEvent *result = 0 ;
27342 int val1 ;
27343 int ecode1 = 0 ;
27344 int val2 ;
27345 int ecode2 = 0 ;
27346 PyObject * obj0 = 0 ;
27347 PyObject * obj1 = 0 ;
27348 char * kwnames[] = {
27349 (char *) "type",(char *) "winid", NULL
27350 };
27351
27352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27353 if (obj0) {
27354 ecode1 = SWIG_AsVal_int(obj0, &val1);
27355 if (!SWIG_IsOK(ecode1)) {
27356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27357 }
27358 arg1 = static_cast< wxEventType >(val1);
27359 }
27360 if (obj1) {
27361 ecode2 = SWIG_AsVal_int(obj1, &val2);
27362 if (!SWIG_IsOK(ecode2)) {
27363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27364 }
27365 arg2 = static_cast< int >(val2);
27366 }
27367 {
27368 PyThreadState* __tstate = wxPyBeginAllowThreads();
27369 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27381 PyObject *obj;
27382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27383 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27384 return SWIG_Py_Void();
27385 }
27386
27387 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27388 return SWIG_Python_InitShadowInstance(args);
27389 }
27390
27391 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27392 PyObject *resultobj = 0;
27393 int arg1 = (int) 0 ;
27394 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27395 wxPyEvent *result = 0 ;
27396 int val1 ;
27397 int ecode1 = 0 ;
27398 int val2 ;
27399 int ecode2 = 0 ;
27400 PyObject * obj0 = 0 ;
27401 PyObject * obj1 = 0 ;
27402 char * kwnames[] = {
27403 (char *) "winid",(char *) "eventType", NULL
27404 };
27405
27406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27407 if (obj0) {
27408 ecode1 = SWIG_AsVal_int(obj0, &val1);
27409 if (!SWIG_IsOK(ecode1)) {
27410 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27411 }
27412 arg1 = static_cast< int >(val1);
27413 }
27414 if (obj1) {
27415 ecode2 = SWIG_AsVal_int(obj1, &val2);
27416 if (!SWIG_IsOK(ecode2)) {
27417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27418 }
27419 arg2 = static_cast< wxEventType >(val2);
27420 }
27421 {
27422 PyThreadState* __tstate = wxPyBeginAllowThreads();
27423 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27424 wxPyEndAllowThreads(__tstate);
27425 if (PyErr_Occurred()) SWIG_fail;
27426 }
27427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27428 return resultobj;
27429 fail:
27430 return NULL;
27431 }
27432
27433
27434 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27435 PyObject *resultobj = 0;
27436 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27437 void *argp1 = 0 ;
27438 int res1 = 0 ;
27439 PyObject *swig_obj[1] ;
27440
27441 if (!args) SWIG_fail;
27442 swig_obj[0] = args;
27443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27444 if (!SWIG_IsOK(res1)) {
27445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27446 }
27447 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27448 {
27449 PyThreadState* __tstate = wxPyBeginAllowThreads();
27450 delete arg1;
27451
27452 wxPyEndAllowThreads(__tstate);
27453 if (PyErr_Occurred()) SWIG_fail;
27454 }
27455 resultobj = SWIG_Py_Void();
27456 return resultobj;
27457 fail:
27458 return NULL;
27459 }
27460
27461
27462 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27463 PyObject *resultobj = 0;
27464 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27465 PyObject *arg2 = (PyObject *) 0 ;
27466 void *argp1 = 0 ;
27467 int res1 = 0 ;
27468 PyObject * obj0 = 0 ;
27469 PyObject * obj1 = 0 ;
27470 char * kwnames[] = {
27471 (char *) "self",(char *) "self", NULL
27472 };
27473
27474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27476 if (!SWIG_IsOK(res1)) {
27477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27478 }
27479 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27480 arg2 = obj1;
27481 {
27482 PyThreadState* __tstate = wxPyBeginAllowThreads();
27483 (arg1)->SetSelf(arg2);
27484 wxPyEndAllowThreads(__tstate);
27485 if (PyErr_Occurred()) SWIG_fail;
27486 }
27487 resultobj = SWIG_Py_Void();
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27495 PyObject *resultobj = 0;
27496 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27497 PyObject *result = 0 ;
27498 void *argp1 = 0 ;
27499 int res1 = 0 ;
27500 PyObject *swig_obj[1] ;
27501
27502 if (!args) SWIG_fail;
27503 swig_obj[0] = args;
27504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27505 if (!SWIG_IsOK(res1)) {
27506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27507 }
27508 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27509 {
27510 PyThreadState* __tstate = wxPyBeginAllowThreads();
27511 result = (PyObject *)(arg1)->GetSelf();
27512 wxPyEndAllowThreads(__tstate);
27513 if (PyErr_Occurred()) SWIG_fail;
27514 }
27515 resultobj = result;
27516 return resultobj;
27517 fail:
27518 return NULL;
27519 }
27520
27521
27522 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27523 PyObject *obj;
27524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27525 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27526 return SWIG_Py_Void();
27527 }
27528
27529 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27530 return SWIG_Python_InitShadowInstance(args);
27531 }
27532
27533 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27534 PyObject *resultobj = 0;
27535 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27536 int arg2 = (int) 0 ;
27537 wxPyCommandEvent *result = 0 ;
27538 int val1 ;
27539 int ecode1 = 0 ;
27540 int val2 ;
27541 int ecode2 = 0 ;
27542 PyObject * obj0 = 0 ;
27543 PyObject * obj1 = 0 ;
27544 char * kwnames[] = {
27545 (char *) "eventType",(char *) "id", NULL
27546 };
27547
27548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27549 if (obj0) {
27550 ecode1 = SWIG_AsVal_int(obj0, &val1);
27551 if (!SWIG_IsOK(ecode1)) {
27552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27553 }
27554 arg1 = static_cast< wxEventType >(val1);
27555 }
27556 if (obj1) {
27557 ecode2 = SWIG_AsVal_int(obj1, &val2);
27558 if (!SWIG_IsOK(ecode2)) {
27559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27560 }
27561 arg2 = static_cast< int >(val2);
27562 }
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27566 wxPyEndAllowThreads(__tstate);
27567 if (PyErr_Occurred()) SWIG_fail;
27568 }
27569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27570 return resultobj;
27571 fail:
27572 return NULL;
27573 }
27574
27575
27576 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27577 PyObject *resultobj = 0;
27578 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27579 void *argp1 = 0 ;
27580 int res1 = 0 ;
27581 PyObject *swig_obj[1] ;
27582
27583 if (!args) SWIG_fail;
27584 swig_obj[0] = args;
27585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27586 if (!SWIG_IsOK(res1)) {
27587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27588 }
27589 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 delete arg1;
27593
27594 wxPyEndAllowThreads(__tstate);
27595 if (PyErr_Occurred()) SWIG_fail;
27596 }
27597 resultobj = SWIG_Py_Void();
27598 return resultobj;
27599 fail:
27600 return NULL;
27601 }
27602
27603
27604 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27605 PyObject *resultobj = 0;
27606 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27607 PyObject *arg2 = (PyObject *) 0 ;
27608 void *argp1 = 0 ;
27609 int res1 = 0 ;
27610 PyObject * obj0 = 0 ;
27611 PyObject * obj1 = 0 ;
27612 char * kwnames[] = {
27613 (char *) "self",(char *) "self", NULL
27614 };
27615
27616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27618 if (!SWIG_IsOK(res1)) {
27619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27620 }
27621 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27622 arg2 = obj1;
27623 {
27624 PyThreadState* __tstate = wxPyBeginAllowThreads();
27625 (arg1)->SetSelf(arg2);
27626 wxPyEndAllowThreads(__tstate);
27627 if (PyErr_Occurred()) SWIG_fail;
27628 }
27629 resultobj = SWIG_Py_Void();
27630 return resultobj;
27631 fail:
27632 return NULL;
27633 }
27634
27635
27636 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27637 PyObject *resultobj = 0;
27638 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27639 PyObject *result = 0 ;
27640 void *argp1 = 0 ;
27641 int res1 = 0 ;
27642 PyObject *swig_obj[1] ;
27643
27644 if (!args) SWIG_fail;
27645 swig_obj[0] = args;
27646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27647 if (!SWIG_IsOK(res1)) {
27648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27649 }
27650 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27651 {
27652 PyThreadState* __tstate = wxPyBeginAllowThreads();
27653 result = (PyObject *)(arg1)->GetSelf();
27654 wxPyEndAllowThreads(__tstate);
27655 if (PyErr_Occurred()) SWIG_fail;
27656 }
27657 resultobj = result;
27658 return resultobj;
27659 fail:
27660 return NULL;
27661 }
27662
27663
27664 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27665 PyObject *obj;
27666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27667 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27668 return SWIG_Py_Void();
27669 }
27670
27671 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27672 return SWIG_Python_InitShadowInstance(args);
27673 }
27674
27675 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27676 PyObject *resultobj = 0;
27677 wxWindow *arg1 = (wxWindow *) 0 ;
27678 wxDateTime *arg2 = 0 ;
27679 wxEventType arg3 ;
27680 wxDateEvent *result = 0 ;
27681 void *argp1 = 0 ;
27682 int res1 = 0 ;
27683 void *argp2 = 0 ;
27684 int res2 = 0 ;
27685 int val3 ;
27686 int ecode3 = 0 ;
27687 PyObject * obj0 = 0 ;
27688 PyObject * obj1 = 0 ;
27689 PyObject * obj2 = 0 ;
27690 char * kwnames[] = {
27691 (char *) "win",(char *) "dt",(char *) "type", NULL
27692 };
27693
27694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27696 if (!SWIG_IsOK(res1)) {
27697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27698 }
27699 arg1 = reinterpret_cast< wxWindow * >(argp1);
27700 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27701 if (!SWIG_IsOK(res2)) {
27702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27703 }
27704 if (!argp2) {
27705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27706 }
27707 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27708 ecode3 = SWIG_AsVal_int(obj2, &val3);
27709 if (!SWIG_IsOK(ecode3)) {
27710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27711 }
27712 arg3 = static_cast< wxEventType >(val3);
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27716 wxPyEndAllowThreads(__tstate);
27717 if (PyErr_Occurred()) SWIG_fail;
27718 }
27719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27720 return resultobj;
27721 fail:
27722 return NULL;
27723 }
27724
27725
27726 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27727 PyObject *resultobj = 0;
27728 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27729 wxDateTime *result = 0 ;
27730 void *argp1 = 0 ;
27731 int res1 = 0 ;
27732 PyObject *swig_obj[1] ;
27733
27734 if (!args) SWIG_fail;
27735 swig_obj[0] = args;
27736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27737 if (!SWIG_IsOK(res1)) {
27738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27739 }
27740 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27741 {
27742 PyThreadState* __tstate = wxPyBeginAllowThreads();
27743 {
27744 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27745 result = (wxDateTime *) &_result_ref;
27746 }
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27751 return resultobj;
27752 fail:
27753 return NULL;
27754 }
27755
27756
27757 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27758 PyObject *resultobj = 0;
27759 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27760 wxDateTime *arg2 = 0 ;
27761 void *argp1 = 0 ;
27762 int res1 = 0 ;
27763 void *argp2 = 0 ;
27764 int res2 = 0 ;
27765 PyObject * obj0 = 0 ;
27766 PyObject * obj1 = 0 ;
27767 char * kwnames[] = {
27768 (char *) "self",(char *) "date", NULL
27769 };
27770
27771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27773 if (!SWIG_IsOK(res1)) {
27774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27775 }
27776 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27777 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27778 if (!SWIG_IsOK(res2)) {
27779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27780 }
27781 if (!argp2) {
27782 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27783 }
27784 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 (arg1)->SetDate((wxDateTime const &)*arg2);
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 resultobj = SWIG_Py_Void();
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27799 PyObject *obj;
27800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27801 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27802 return SWIG_Py_Void();
27803 }
27804
27805 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27806 return SWIG_Python_InitShadowInstance(args);
27807 }
27808
27809 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27810 PyObject *resultobj = 0;
27811 wxPyApp *result = 0 ;
27812
27813 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 result = (wxPyApp *)new_wxPyApp();
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27828 PyObject *resultobj = 0;
27829 wxPyApp *arg1 = (wxPyApp *) 0 ;
27830 void *argp1 = 0 ;
27831 int res1 = 0 ;
27832 PyObject *swig_obj[1] ;
27833
27834 if (!args) SWIG_fail;
27835 swig_obj[0] = args;
27836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27837 if (!SWIG_IsOK(res1)) {
27838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27839 }
27840 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27841 {
27842 PyThreadState* __tstate = wxPyBeginAllowThreads();
27843 delete arg1;
27844
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 resultobj = SWIG_Py_Void();
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27856 PyObject *resultobj = 0;
27857 wxPyApp *arg1 = (wxPyApp *) 0 ;
27858 PyObject *arg2 = (PyObject *) 0 ;
27859 PyObject *arg3 = (PyObject *) 0 ;
27860 bool arg4 ;
27861 void *argp1 = 0 ;
27862 int res1 = 0 ;
27863 bool val4 ;
27864 int ecode4 = 0 ;
27865 PyObject * obj0 = 0 ;
27866 PyObject * obj1 = 0 ;
27867 PyObject * obj2 = 0 ;
27868 PyObject * obj3 = 0 ;
27869 char * kwnames[] = {
27870 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27871 };
27872
27873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27875 if (!SWIG_IsOK(res1)) {
27876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27877 }
27878 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27879 arg2 = obj1;
27880 arg3 = obj2;
27881 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27882 if (!SWIG_IsOK(ecode4)) {
27883 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27884 }
27885 arg4 = static_cast< bool >(val4);
27886 {
27887 PyThreadState* __tstate = wxPyBeginAllowThreads();
27888 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 resultobj = SWIG_Py_Void();
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27900 PyObject *resultobj = 0;
27901 wxPyApp *arg1 = (wxPyApp *) 0 ;
27902 wxString result;
27903 void *argp1 = 0 ;
27904 int res1 = 0 ;
27905 PyObject *swig_obj[1] ;
27906
27907 if (!args) SWIG_fail;
27908 swig_obj[0] = args;
27909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27910 if (!SWIG_IsOK(res1)) {
27911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27912 }
27913 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 result = ((wxPyApp const *)arg1)->GetAppName();
27917 wxPyEndAllowThreads(__tstate);
27918 if (PyErr_Occurred()) SWIG_fail;
27919 }
27920 {
27921 #if wxUSE_UNICODE
27922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27923 #else
27924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27925 #endif
27926 }
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj = 0;
27935 wxPyApp *arg1 = (wxPyApp *) 0 ;
27936 wxString *arg2 = 0 ;
27937 void *argp1 = 0 ;
27938 int res1 = 0 ;
27939 bool temp2 = false ;
27940 PyObject * obj0 = 0 ;
27941 PyObject * obj1 = 0 ;
27942 char * kwnames[] = {
27943 (char *) "self",(char *) "name", NULL
27944 };
27945
27946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27948 if (!SWIG_IsOK(res1)) {
27949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27950 }
27951 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27952 {
27953 arg2 = wxString_in_helper(obj1);
27954 if (arg2 == NULL) SWIG_fail;
27955 temp2 = true;
27956 }
27957 {
27958 PyThreadState* __tstate = wxPyBeginAllowThreads();
27959 (arg1)->SetAppName((wxString const &)*arg2);
27960 wxPyEndAllowThreads(__tstate);
27961 if (PyErr_Occurred()) SWIG_fail;
27962 }
27963 resultobj = SWIG_Py_Void();
27964 {
27965 if (temp2)
27966 delete arg2;
27967 }
27968 return resultobj;
27969 fail:
27970 {
27971 if (temp2)
27972 delete arg2;
27973 }
27974 return NULL;
27975 }
27976
27977
27978 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27979 PyObject *resultobj = 0;
27980 wxPyApp *arg1 = (wxPyApp *) 0 ;
27981 wxString result;
27982 void *argp1 = 0 ;
27983 int res1 = 0 ;
27984 PyObject *swig_obj[1] ;
27985
27986 if (!args) SWIG_fail;
27987 swig_obj[0] = args;
27988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27989 if (!SWIG_IsOK(res1)) {
27990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27991 }
27992 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27993 {
27994 PyThreadState* __tstate = wxPyBeginAllowThreads();
27995 result = ((wxPyApp const *)arg1)->GetClassName();
27996 wxPyEndAllowThreads(__tstate);
27997 if (PyErr_Occurred()) SWIG_fail;
27998 }
27999 {
28000 #if wxUSE_UNICODE
28001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28002 #else
28003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28004 #endif
28005 }
28006 return resultobj;
28007 fail:
28008 return NULL;
28009 }
28010
28011
28012 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28013 PyObject *resultobj = 0;
28014 wxPyApp *arg1 = (wxPyApp *) 0 ;
28015 wxString *arg2 = 0 ;
28016 void *argp1 = 0 ;
28017 int res1 = 0 ;
28018 bool temp2 = false ;
28019 PyObject * obj0 = 0 ;
28020 PyObject * obj1 = 0 ;
28021 char * kwnames[] = {
28022 (char *) "self",(char *) "name", NULL
28023 };
28024
28025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
28026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28027 if (!SWIG_IsOK(res1)) {
28028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28029 }
28030 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28031 {
28032 arg2 = wxString_in_helper(obj1);
28033 if (arg2 == NULL) SWIG_fail;
28034 temp2 = true;
28035 }
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 (arg1)->SetClassName((wxString const &)*arg2);
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 resultobj = SWIG_Py_Void();
28043 {
28044 if (temp2)
28045 delete arg2;
28046 }
28047 return resultobj;
28048 fail:
28049 {
28050 if (temp2)
28051 delete arg2;
28052 }
28053 return NULL;
28054 }
28055
28056
28057 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28058 PyObject *resultobj = 0;
28059 wxPyApp *arg1 = (wxPyApp *) 0 ;
28060 wxString *result = 0 ;
28061 void *argp1 = 0 ;
28062 int res1 = 0 ;
28063 PyObject *swig_obj[1] ;
28064
28065 if (!args) SWIG_fail;
28066 swig_obj[0] = args;
28067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28068 if (!SWIG_IsOK(res1)) {
28069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28070 }
28071 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28072 {
28073 PyThreadState* __tstate = wxPyBeginAllowThreads();
28074 {
28075 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
28076 result = (wxString *) &_result_ref;
28077 }
28078 wxPyEndAllowThreads(__tstate);
28079 if (PyErr_Occurred()) SWIG_fail;
28080 }
28081 {
28082 #if wxUSE_UNICODE
28083 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
28084 #else
28085 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
28086 #endif
28087 }
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28095 PyObject *resultobj = 0;
28096 wxPyApp *arg1 = (wxPyApp *) 0 ;
28097 wxString *arg2 = 0 ;
28098 void *argp1 = 0 ;
28099 int res1 = 0 ;
28100 bool temp2 = false ;
28101 PyObject * obj0 = 0 ;
28102 PyObject * obj1 = 0 ;
28103 char * kwnames[] = {
28104 (char *) "self",(char *) "name", NULL
28105 };
28106
28107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
28108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28109 if (!SWIG_IsOK(res1)) {
28110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28111 }
28112 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28113 {
28114 arg2 = wxString_in_helper(obj1);
28115 if (arg2 == NULL) SWIG_fail;
28116 temp2 = true;
28117 }
28118 {
28119 PyThreadState* __tstate = wxPyBeginAllowThreads();
28120 (arg1)->SetVendorName((wxString const &)*arg2);
28121 wxPyEndAllowThreads(__tstate);
28122 if (PyErr_Occurred()) SWIG_fail;
28123 }
28124 resultobj = SWIG_Py_Void();
28125 {
28126 if (temp2)
28127 delete arg2;
28128 }
28129 return resultobj;
28130 fail:
28131 {
28132 if (temp2)
28133 delete arg2;
28134 }
28135 return NULL;
28136 }
28137
28138
28139 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28140 PyObject *resultobj = 0;
28141 wxPyApp *arg1 = (wxPyApp *) 0 ;
28142 wxAppTraits *result = 0 ;
28143 void *argp1 = 0 ;
28144 int res1 = 0 ;
28145 PyObject *swig_obj[1] ;
28146
28147 if (!args) SWIG_fail;
28148 swig_obj[0] = args;
28149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28150 if (!SWIG_IsOK(res1)) {
28151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28152 }
28153 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28154 {
28155 PyThreadState* __tstate = wxPyBeginAllowThreads();
28156 result = (wxAppTraits *)(arg1)->GetTraits();
28157 wxPyEndAllowThreads(__tstate);
28158 if (PyErr_Occurred()) SWIG_fail;
28159 }
28160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28161 return resultobj;
28162 fail:
28163 return NULL;
28164 }
28165
28166
28167 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28168 PyObject *resultobj = 0;
28169 wxPyApp *arg1 = (wxPyApp *) 0 ;
28170 void *argp1 = 0 ;
28171 int res1 = 0 ;
28172 PyObject *swig_obj[1] ;
28173
28174 if (!args) SWIG_fail;
28175 swig_obj[0] = args;
28176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28177 if (!SWIG_IsOK(res1)) {
28178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28179 }
28180 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28181 {
28182 PyThreadState* __tstate = wxPyBeginAllowThreads();
28183 (arg1)->ProcessPendingEvents();
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 resultobj = SWIG_Py_Void();
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj = 0;
28196 wxPyApp *arg1 = (wxPyApp *) 0 ;
28197 bool arg2 = (bool) false ;
28198 bool result;
28199 void *argp1 = 0 ;
28200 int res1 = 0 ;
28201 bool val2 ;
28202 int ecode2 = 0 ;
28203 PyObject * obj0 = 0 ;
28204 PyObject * obj1 = 0 ;
28205 char * kwnames[] = {
28206 (char *) "self",(char *) "onlyIfNeeded", NULL
28207 };
28208
28209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28211 if (!SWIG_IsOK(res1)) {
28212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28213 }
28214 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28215 if (obj1) {
28216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28217 if (!SWIG_IsOK(ecode2)) {
28218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28219 }
28220 arg2 = static_cast< bool >(val2);
28221 }
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 result = (bool)(arg1)->Yield(arg2);
28225 wxPyEndAllowThreads(__tstate);
28226 if (PyErr_Occurred()) SWIG_fail;
28227 }
28228 {
28229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28230 }
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *resultobj = 0;
28239 wxPyApp *arg1 = (wxPyApp *) 0 ;
28240 void *argp1 = 0 ;
28241 int res1 = 0 ;
28242 PyObject *swig_obj[1] ;
28243
28244 if (!args) SWIG_fail;
28245 swig_obj[0] = args;
28246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28247 if (!SWIG_IsOK(res1)) {
28248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28249 }
28250 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28251 {
28252 PyThreadState* __tstate = wxPyBeginAllowThreads();
28253 (arg1)->WakeUpIdle();
28254 wxPyEndAllowThreads(__tstate);
28255 if (PyErr_Occurred()) SWIG_fail;
28256 }
28257 resultobj = SWIG_Py_Void();
28258 return resultobj;
28259 fail:
28260 return NULL;
28261 }
28262
28263
28264 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28265 PyObject *resultobj = 0;
28266 bool result;
28267
28268 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28269 {
28270 PyThreadState* __tstate = wxPyBeginAllowThreads();
28271 result = (bool)wxPyApp::IsMainLoopRunning();
28272 wxPyEndAllowThreads(__tstate);
28273 if (PyErr_Occurred()) SWIG_fail;
28274 }
28275 {
28276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28277 }
28278 return resultobj;
28279 fail:
28280 return NULL;
28281 }
28282
28283
28284 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28285 PyObject *resultobj = 0;
28286 wxPyApp *arg1 = (wxPyApp *) 0 ;
28287 int result;
28288 void *argp1 = 0 ;
28289 int res1 = 0 ;
28290 PyObject *swig_obj[1] ;
28291
28292 if (!args) SWIG_fail;
28293 swig_obj[0] = args;
28294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28295 if (!SWIG_IsOK(res1)) {
28296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28297 }
28298 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28299 {
28300 PyThreadState* __tstate = wxPyBeginAllowThreads();
28301 result = (int)(arg1)->MainLoop();
28302 wxPyEndAllowThreads(__tstate);
28303 if (PyErr_Occurred()) SWIG_fail;
28304 }
28305 resultobj = SWIG_From_int(static_cast< int >(result));
28306 return resultobj;
28307 fail:
28308 return NULL;
28309 }
28310
28311
28312 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28313 PyObject *resultobj = 0;
28314 wxPyApp *arg1 = (wxPyApp *) 0 ;
28315 void *argp1 = 0 ;
28316 int res1 = 0 ;
28317 PyObject *swig_obj[1] ;
28318
28319 if (!args) SWIG_fail;
28320 swig_obj[0] = args;
28321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28322 if (!SWIG_IsOK(res1)) {
28323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28324 }
28325 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28326 {
28327 PyThreadState* __tstate = wxPyBeginAllowThreads();
28328 (arg1)->Exit();
28329 wxPyEndAllowThreads(__tstate);
28330 if (PyErr_Occurred()) SWIG_fail;
28331 }
28332 resultobj = SWIG_Py_Void();
28333 return resultobj;
28334 fail:
28335 return NULL;
28336 }
28337
28338
28339 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28340 PyObject *resultobj = 0;
28341 wxPyApp *arg1 = (wxPyApp *) 0 ;
28342 wxLayoutDirection result;
28343 void *argp1 = 0 ;
28344 int res1 = 0 ;
28345 PyObject *swig_obj[1] ;
28346
28347 if (!args) SWIG_fail;
28348 swig_obj[0] = args;
28349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28350 if (!SWIG_IsOK(res1)) {
28351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28352 }
28353 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28354 {
28355 PyThreadState* __tstate = wxPyBeginAllowThreads();
28356 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28357 wxPyEndAllowThreads(__tstate);
28358 if (PyErr_Occurred()) SWIG_fail;
28359 }
28360 resultobj = SWIG_From_int(static_cast< int >(result));
28361 return resultobj;
28362 fail:
28363 return NULL;
28364 }
28365
28366
28367 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28368 PyObject *resultobj = 0;
28369 wxPyApp *arg1 = (wxPyApp *) 0 ;
28370 void *argp1 = 0 ;
28371 int res1 = 0 ;
28372 PyObject *swig_obj[1] ;
28373
28374 if (!args) SWIG_fail;
28375 swig_obj[0] = args;
28376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28377 if (!SWIG_IsOK(res1)) {
28378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28379 }
28380 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28381 {
28382 PyThreadState* __tstate = wxPyBeginAllowThreads();
28383 (arg1)->ExitMainLoop();
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 resultobj = SWIG_Py_Void();
28388 return resultobj;
28389 fail:
28390 return NULL;
28391 }
28392
28393
28394 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28395 PyObject *resultobj = 0;
28396 wxPyApp *arg1 = (wxPyApp *) 0 ;
28397 bool result;
28398 void *argp1 = 0 ;
28399 int res1 = 0 ;
28400 PyObject *swig_obj[1] ;
28401
28402 if (!args) SWIG_fail;
28403 swig_obj[0] = args;
28404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28405 if (!SWIG_IsOK(res1)) {
28406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28407 }
28408 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28409 {
28410 PyThreadState* __tstate = wxPyBeginAllowThreads();
28411 result = (bool)(arg1)->Pending();
28412 wxPyEndAllowThreads(__tstate);
28413 if (PyErr_Occurred()) SWIG_fail;
28414 }
28415 {
28416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28417 }
28418 return resultobj;
28419 fail:
28420 return NULL;
28421 }
28422
28423
28424 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28425 PyObject *resultobj = 0;
28426 wxPyApp *arg1 = (wxPyApp *) 0 ;
28427 bool result;
28428 void *argp1 = 0 ;
28429 int res1 = 0 ;
28430 PyObject *swig_obj[1] ;
28431
28432 if (!args) SWIG_fail;
28433 swig_obj[0] = args;
28434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28435 if (!SWIG_IsOK(res1)) {
28436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28437 }
28438 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28439 {
28440 PyThreadState* __tstate = wxPyBeginAllowThreads();
28441 result = (bool)(arg1)->Dispatch();
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 {
28446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28447 }
28448 return resultobj;
28449 fail:
28450 return NULL;
28451 }
28452
28453
28454 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28455 PyObject *resultobj = 0;
28456 wxPyApp *arg1 = (wxPyApp *) 0 ;
28457 bool result;
28458 void *argp1 = 0 ;
28459 int res1 = 0 ;
28460 PyObject *swig_obj[1] ;
28461
28462 if (!args) SWIG_fail;
28463 swig_obj[0] = args;
28464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28465 if (!SWIG_IsOK(res1)) {
28466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28467 }
28468 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28469 {
28470 PyThreadState* __tstate = wxPyBeginAllowThreads();
28471 result = (bool)(arg1)->ProcessIdle();
28472 wxPyEndAllowThreads(__tstate);
28473 if (PyErr_Occurred()) SWIG_fail;
28474 }
28475 {
28476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28477 }
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28485 PyObject *resultobj = 0;
28486 wxPyApp *arg1 = (wxPyApp *) 0 ;
28487 wxWindow *arg2 = (wxWindow *) 0 ;
28488 wxIdleEvent *arg3 = 0 ;
28489 bool result;
28490 void *argp1 = 0 ;
28491 int res1 = 0 ;
28492 void *argp2 = 0 ;
28493 int res2 = 0 ;
28494 void *argp3 = 0 ;
28495 int res3 = 0 ;
28496 PyObject * obj0 = 0 ;
28497 PyObject * obj1 = 0 ;
28498 PyObject * obj2 = 0 ;
28499 char * kwnames[] = {
28500 (char *) "self",(char *) "win",(char *) "event", NULL
28501 };
28502
28503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28505 if (!SWIG_IsOK(res1)) {
28506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28507 }
28508 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28510 if (!SWIG_IsOK(res2)) {
28511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28512 }
28513 arg2 = reinterpret_cast< wxWindow * >(argp2);
28514 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28515 if (!SWIG_IsOK(res3)) {
28516 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28517 }
28518 if (!argp3) {
28519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28520 }
28521 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 {
28529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28530 }
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28538 PyObject *resultobj = 0;
28539 wxPyApp *arg1 = (wxPyApp *) 0 ;
28540 bool result;
28541 void *argp1 = 0 ;
28542 int res1 = 0 ;
28543 PyObject *swig_obj[1] ;
28544
28545 if (!args) SWIG_fail;
28546 swig_obj[0] = args;
28547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28548 if (!SWIG_IsOK(res1)) {
28549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28550 }
28551 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 result = (bool)((wxPyApp const *)arg1)->IsActive();
28555 wxPyEndAllowThreads(__tstate);
28556 if (PyErr_Occurred()) SWIG_fail;
28557 }
28558 {
28559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28560 }
28561 return resultobj;
28562 fail:
28563 return NULL;
28564 }
28565
28566
28567 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28568 PyObject *resultobj = 0;
28569 wxPyApp *arg1 = (wxPyApp *) 0 ;
28570 wxWindow *arg2 = (wxWindow *) 0 ;
28571 void *argp1 = 0 ;
28572 int res1 = 0 ;
28573 void *argp2 = 0 ;
28574 int res2 = 0 ;
28575 PyObject * obj0 = 0 ;
28576 PyObject * obj1 = 0 ;
28577 char * kwnames[] = {
28578 (char *) "self",(char *) "win", NULL
28579 };
28580
28581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28583 if (!SWIG_IsOK(res1)) {
28584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28585 }
28586 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28588 if (!SWIG_IsOK(res2)) {
28589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28590 }
28591 arg2 = reinterpret_cast< wxWindow * >(argp2);
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 (arg1)->SetTopWindow(arg2);
28595 wxPyEndAllowThreads(__tstate);
28596 if (PyErr_Occurred()) SWIG_fail;
28597 }
28598 resultobj = SWIG_Py_Void();
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28606 PyObject *resultobj = 0;
28607 wxPyApp *arg1 = (wxPyApp *) 0 ;
28608 wxWindow *result = 0 ;
28609 void *argp1 = 0 ;
28610 int res1 = 0 ;
28611 PyObject *swig_obj[1] ;
28612
28613 if (!args) SWIG_fail;
28614 swig_obj[0] = args;
28615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28616 if (!SWIG_IsOK(res1)) {
28617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28618 }
28619 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 {
28627 resultobj = wxPyMake_wxObject(result, (bool)0);
28628 }
28629 return resultobj;
28630 fail:
28631 return NULL;
28632 }
28633
28634
28635 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28636 PyObject *resultobj = 0;
28637 wxPyApp *arg1 = (wxPyApp *) 0 ;
28638 bool arg2 ;
28639 void *argp1 = 0 ;
28640 int res1 = 0 ;
28641 bool val2 ;
28642 int ecode2 = 0 ;
28643 PyObject * obj0 = 0 ;
28644 PyObject * obj1 = 0 ;
28645 char * kwnames[] = {
28646 (char *) "self",(char *) "flag", NULL
28647 };
28648
28649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28651 if (!SWIG_IsOK(res1)) {
28652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28653 }
28654 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28655 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28656 if (!SWIG_IsOK(ecode2)) {
28657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28658 }
28659 arg2 = static_cast< bool >(val2);
28660 {
28661 PyThreadState* __tstate = wxPyBeginAllowThreads();
28662 (arg1)->SetExitOnFrameDelete(arg2);
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 resultobj = SWIG_Py_Void();
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28674 PyObject *resultobj = 0;
28675 wxPyApp *arg1 = (wxPyApp *) 0 ;
28676 bool result;
28677 void *argp1 = 0 ;
28678 int res1 = 0 ;
28679 PyObject *swig_obj[1] ;
28680
28681 if (!args) SWIG_fail;
28682 swig_obj[0] = args;
28683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28684 if (!SWIG_IsOK(res1)) {
28685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28686 }
28687 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28688 {
28689 PyThreadState* __tstate = wxPyBeginAllowThreads();
28690 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28691 wxPyEndAllowThreads(__tstate);
28692 if (PyErr_Occurred()) SWIG_fail;
28693 }
28694 {
28695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28696 }
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj = 0;
28705 wxPyApp *arg1 = (wxPyApp *) 0 ;
28706 bool arg2 ;
28707 void *argp1 = 0 ;
28708 int res1 = 0 ;
28709 bool val2 ;
28710 int ecode2 = 0 ;
28711 PyObject * obj0 = 0 ;
28712 PyObject * obj1 = 0 ;
28713 char * kwnames[] = {
28714 (char *) "self",(char *) "flag", NULL
28715 };
28716
28717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28719 if (!SWIG_IsOK(res1)) {
28720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28721 }
28722 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28724 if (!SWIG_IsOK(ecode2)) {
28725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28726 }
28727 arg2 = static_cast< bool >(val2);
28728 {
28729 PyThreadState* __tstate = wxPyBeginAllowThreads();
28730 (arg1)->SetUseBestVisual(arg2);
28731 wxPyEndAllowThreads(__tstate);
28732 if (PyErr_Occurred()) SWIG_fail;
28733 }
28734 resultobj = SWIG_Py_Void();
28735 return resultobj;
28736 fail:
28737 return NULL;
28738 }
28739
28740
28741 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28742 PyObject *resultobj = 0;
28743 wxPyApp *arg1 = (wxPyApp *) 0 ;
28744 bool result;
28745 void *argp1 = 0 ;
28746 int res1 = 0 ;
28747 PyObject *swig_obj[1] ;
28748
28749 if (!args) SWIG_fail;
28750 swig_obj[0] = args;
28751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28752 if (!SWIG_IsOK(res1)) {
28753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28754 }
28755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28756 {
28757 PyThreadState* __tstate = wxPyBeginAllowThreads();
28758 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28759 wxPyEndAllowThreads(__tstate);
28760 if (PyErr_Occurred()) SWIG_fail;
28761 }
28762 {
28763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28764 }
28765 return resultobj;
28766 fail:
28767 return NULL;
28768 }
28769
28770
28771 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28772 PyObject *resultobj = 0;
28773 wxPyApp *arg1 = (wxPyApp *) 0 ;
28774 int arg2 ;
28775 void *argp1 = 0 ;
28776 int res1 = 0 ;
28777 int val2 ;
28778 int ecode2 = 0 ;
28779 PyObject * obj0 = 0 ;
28780 PyObject * obj1 = 0 ;
28781 char * kwnames[] = {
28782 (char *) "self",(char *) "mode", NULL
28783 };
28784
28785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28787 if (!SWIG_IsOK(res1)) {
28788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28789 }
28790 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28791 ecode2 = SWIG_AsVal_int(obj1, &val2);
28792 if (!SWIG_IsOK(ecode2)) {
28793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28794 }
28795 arg2 = static_cast< int >(val2);
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 (arg1)->SetPrintMode(arg2);
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 resultobj = SWIG_Py_Void();
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28810 PyObject *resultobj = 0;
28811 wxPyApp *arg1 = (wxPyApp *) 0 ;
28812 int result;
28813 void *argp1 = 0 ;
28814 int res1 = 0 ;
28815 PyObject *swig_obj[1] ;
28816
28817 if (!args) SWIG_fail;
28818 swig_obj[0] = args;
28819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28820 if (!SWIG_IsOK(res1)) {
28821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28822 }
28823 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28824 {
28825 PyThreadState* __tstate = wxPyBeginAllowThreads();
28826 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28827 wxPyEndAllowThreads(__tstate);
28828 if (PyErr_Occurred()) SWIG_fail;
28829 }
28830 resultobj = SWIG_From_int(static_cast< int >(result));
28831 return resultobj;
28832 fail:
28833 return NULL;
28834 }
28835
28836
28837 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28838 PyObject *resultobj = 0;
28839 wxPyApp *arg1 = (wxPyApp *) 0 ;
28840 int arg2 ;
28841 void *argp1 = 0 ;
28842 int res1 = 0 ;
28843 int val2 ;
28844 int ecode2 = 0 ;
28845 PyObject * obj0 = 0 ;
28846 PyObject * obj1 = 0 ;
28847 char * kwnames[] = {
28848 (char *) "self",(char *) "mode", NULL
28849 };
28850
28851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28853 if (!SWIG_IsOK(res1)) {
28854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28855 }
28856 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28857 ecode2 = SWIG_AsVal_int(obj1, &val2);
28858 if (!SWIG_IsOK(ecode2)) {
28859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28860 }
28861 arg2 = static_cast< int >(val2);
28862 {
28863 PyThreadState* __tstate = wxPyBeginAllowThreads();
28864 (arg1)->SetAssertMode(arg2);
28865 wxPyEndAllowThreads(__tstate);
28866 if (PyErr_Occurred()) SWIG_fail;
28867 }
28868 resultobj = SWIG_Py_Void();
28869 return resultobj;
28870 fail:
28871 return NULL;
28872 }
28873
28874
28875 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28876 PyObject *resultobj = 0;
28877 wxPyApp *arg1 = (wxPyApp *) 0 ;
28878 int result;
28879 void *argp1 = 0 ;
28880 int res1 = 0 ;
28881 PyObject *swig_obj[1] ;
28882
28883 if (!args) SWIG_fail;
28884 swig_obj[0] = args;
28885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28886 if (!SWIG_IsOK(res1)) {
28887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28888 }
28889 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28890 {
28891 PyThreadState* __tstate = wxPyBeginAllowThreads();
28892 result = (int)(arg1)->GetAssertMode();
28893 wxPyEndAllowThreads(__tstate);
28894 if (PyErr_Occurred()) SWIG_fail;
28895 }
28896 resultobj = SWIG_From_int(static_cast< int >(result));
28897 return resultobj;
28898 fail:
28899 return NULL;
28900 }
28901
28902
28903 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28904 PyObject *resultobj = 0;
28905 bool result;
28906
28907 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28908 {
28909 PyThreadState* __tstate = wxPyBeginAllowThreads();
28910 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28911 wxPyEndAllowThreads(__tstate);
28912 if (PyErr_Occurred()) SWIG_fail;
28913 }
28914 {
28915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28916 }
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28924 PyObject *resultobj = 0;
28925 long result;
28926
28927 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (long)wxPyApp::GetMacAboutMenuItemId();
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 resultobj = SWIG_From_long(static_cast< long >(result));
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28942 PyObject *resultobj = 0;
28943 long result;
28944
28945 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28946 {
28947 PyThreadState* __tstate = wxPyBeginAllowThreads();
28948 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28949 wxPyEndAllowThreads(__tstate);
28950 if (PyErr_Occurred()) SWIG_fail;
28951 }
28952 resultobj = SWIG_From_long(static_cast< long >(result));
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28960 PyObject *resultobj = 0;
28961 long result;
28962
28963 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28964 {
28965 PyThreadState* __tstate = wxPyBeginAllowThreads();
28966 result = (long)wxPyApp::GetMacExitMenuItemId();
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 resultobj = SWIG_From_long(static_cast< long >(result));
28971 return resultobj;
28972 fail:
28973 return NULL;
28974 }
28975
28976
28977 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28978 PyObject *resultobj = 0;
28979 wxString result;
28980
28981 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28982 {
28983 PyThreadState* __tstate = wxPyBeginAllowThreads();
28984 result = wxPyApp::GetMacHelpMenuTitleName();
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 {
28989 #if wxUSE_UNICODE
28990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28991 #else
28992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28993 #endif
28994 }
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29002 PyObject *resultobj = 0;
29003 bool arg1 ;
29004 bool val1 ;
29005 int ecode1 = 0 ;
29006 PyObject * obj0 = 0 ;
29007 char * kwnames[] = {
29008 (char *) "val", NULL
29009 };
29010
29011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
29012 ecode1 = SWIG_AsVal_bool(obj0, &val1);
29013 if (!SWIG_IsOK(ecode1)) {
29014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
29015 }
29016 arg1 = static_cast< bool >(val1);
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
29020 wxPyEndAllowThreads(__tstate);
29021 if (PyErr_Occurred()) SWIG_fail;
29022 }
29023 resultobj = SWIG_Py_Void();
29024 return resultobj;
29025 fail:
29026 return NULL;
29027 }
29028
29029
29030 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj = 0;
29032 long arg1 ;
29033 long val1 ;
29034 int ecode1 = 0 ;
29035 PyObject * obj0 = 0 ;
29036 char * kwnames[] = {
29037 (char *) "val", NULL
29038 };
29039
29040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
29041 ecode1 = SWIG_AsVal_long(obj0, &val1);
29042 if (!SWIG_IsOK(ecode1)) {
29043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
29044 }
29045 arg1 = static_cast< long >(val1);
29046 {
29047 PyThreadState* __tstate = wxPyBeginAllowThreads();
29048 wxPyApp::SetMacAboutMenuItemId(arg1);
29049 wxPyEndAllowThreads(__tstate);
29050 if (PyErr_Occurred()) SWIG_fail;
29051 }
29052 resultobj = SWIG_Py_Void();
29053 return resultobj;
29054 fail:
29055 return NULL;
29056 }
29057
29058
29059 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29060 PyObject *resultobj = 0;
29061 long arg1 ;
29062 long val1 ;
29063 int ecode1 = 0 ;
29064 PyObject * obj0 = 0 ;
29065 char * kwnames[] = {
29066 (char *) "val", NULL
29067 };
29068
29069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
29070 ecode1 = SWIG_AsVal_long(obj0, &val1);
29071 if (!SWIG_IsOK(ecode1)) {
29072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
29073 }
29074 arg1 = static_cast< long >(val1);
29075 {
29076 PyThreadState* __tstate = wxPyBeginAllowThreads();
29077 wxPyApp::SetMacPreferencesMenuItemId(arg1);
29078 wxPyEndAllowThreads(__tstate);
29079 if (PyErr_Occurred()) SWIG_fail;
29080 }
29081 resultobj = SWIG_Py_Void();
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29089 PyObject *resultobj = 0;
29090 long arg1 ;
29091 long val1 ;
29092 int ecode1 = 0 ;
29093 PyObject * obj0 = 0 ;
29094 char * kwnames[] = {
29095 (char *) "val", NULL
29096 };
29097
29098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
29099 ecode1 = SWIG_AsVal_long(obj0, &val1);
29100 if (!SWIG_IsOK(ecode1)) {
29101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
29102 }
29103 arg1 = static_cast< long >(val1);
29104 {
29105 PyThreadState* __tstate = wxPyBeginAllowThreads();
29106 wxPyApp::SetMacExitMenuItemId(arg1);
29107 wxPyEndAllowThreads(__tstate);
29108 if (PyErr_Occurred()) SWIG_fail;
29109 }
29110 resultobj = SWIG_Py_Void();
29111 return resultobj;
29112 fail:
29113 return NULL;
29114 }
29115
29116
29117 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29118 PyObject *resultobj = 0;
29119 wxString *arg1 = 0 ;
29120 bool temp1 = false ;
29121 PyObject * obj0 = 0 ;
29122 char * kwnames[] = {
29123 (char *) "val", NULL
29124 };
29125
29126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29127 {
29128 arg1 = wxString_in_helper(obj0);
29129 if (arg1 == NULL) SWIG_fail;
29130 temp1 = true;
29131 }
29132 {
29133 PyThreadState* __tstate = wxPyBeginAllowThreads();
29134 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29135 wxPyEndAllowThreads(__tstate);
29136 if (PyErr_Occurred()) SWIG_fail;
29137 }
29138 resultobj = SWIG_Py_Void();
29139 {
29140 if (temp1)
29141 delete arg1;
29142 }
29143 return resultobj;
29144 fail:
29145 {
29146 if (temp1)
29147 delete arg1;
29148 }
29149 return NULL;
29150 }
29151
29152
29153 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29154 PyObject *resultobj = 0;
29155 wxPyApp *arg1 = (wxPyApp *) 0 ;
29156 void *argp1 = 0 ;
29157 int res1 = 0 ;
29158 PyObject *swig_obj[1] ;
29159
29160 if (!args) SWIG_fail;
29161 swig_obj[0] = args;
29162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29163 if (!SWIG_IsOK(res1)) {
29164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29165 }
29166 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29167 {
29168 PyThreadState* __tstate = wxPyBeginAllowThreads();
29169 (arg1)->_BootstrapApp();
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 resultobj = SWIG_Py_Void();
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29181 PyObject *resultobj = 0;
29182 int result;
29183
29184 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29185 {
29186 PyThreadState* __tstate = wxPyBeginAllowThreads();
29187 result = (int)wxPyApp::GetComCtl32Version();
29188 wxPyEndAllowThreads(__tstate);
29189 if (PyErr_Occurred()) SWIG_fail;
29190 }
29191 resultobj = SWIG_From_int(static_cast< int >(result));
29192 return resultobj;
29193 fail:
29194 return NULL;
29195 }
29196
29197
29198 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29199 PyObject *resultobj = 0;
29200 bool result;
29201
29202 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29203 {
29204 PyThreadState* __tstate = wxPyBeginAllowThreads();
29205 result = (bool)wxPyApp_IsDisplayAvailable();
29206 wxPyEndAllowThreads(__tstate);
29207 if (PyErr_Occurred()) SWIG_fail;
29208 }
29209 {
29210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29211 }
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29219 PyObject *obj;
29220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29221 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29222 return SWIG_Py_Void();
29223 }
29224
29225 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29226 return SWIG_Python_InitShadowInstance(args);
29227 }
29228
29229 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29230 PyObject *resultobj = 0;
29231
29232 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29233 {
29234 PyThreadState* __tstate = wxPyBeginAllowThreads();
29235 wxExit();
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 resultobj = SWIG_Py_Void();
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29247 PyObject *resultobj = 0;
29248 bool result;
29249
29250 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29251 {
29252 PyThreadState* __tstate = wxPyBeginAllowThreads();
29253 result = (bool)wxYield();
29254 wxPyEndAllowThreads(__tstate);
29255 if (PyErr_Occurred()) SWIG_fail;
29256 }
29257 {
29258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29259 }
29260 return resultobj;
29261 fail:
29262 return NULL;
29263 }
29264
29265
29266 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29267 PyObject *resultobj = 0;
29268 bool result;
29269
29270 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29271 {
29272 PyThreadState* __tstate = wxPyBeginAllowThreads();
29273 result = (bool)wxYieldIfNeeded();
29274 wxPyEndAllowThreads(__tstate);
29275 if (PyErr_Occurred()) SWIG_fail;
29276 }
29277 {
29278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29279 }
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29287 PyObject *resultobj = 0;
29288 wxWindow *arg1 = (wxWindow *) NULL ;
29289 bool arg2 = (bool) false ;
29290 bool result;
29291 void *argp1 = 0 ;
29292 int res1 = 0 ;
29293 bool val2 ;
29294 int ecode2 = 0 ;
29295 PyObject * obj0 = 0 ;
29296 PyObject * obj1 = 0 ;
29297 char * kwnames[] = {
29298 (char *) "win",(char *) "onlyIfNeeded", NULL
29299 };
29300
29301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29302 if (obj0) {
29303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29304 if (!SWIG_IsOK(res1)) {
29305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29306 }
29307 arg1 = reinterpret_cast< wxWindow * >(argp1);
29308 }
29309 if (obj1) {
29310 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29311 if (!SWIG_IsOK(ecode2)) {
29312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29313 }
29314 arg2 = static_cast< bool >(val2);
29315 }
29316 {
29317 PyThreadState* __tstate = wxPyBeginAllowThreads();
29318 result = (bool)wxSafeYield(arg1,arg2);
29319 wxPyEndAllowThreads(__tstate);
29320 if (PyErr_Occurred()) SWIG_fail;
29321 }
29322 {
29323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29324 }
29325 return resultobj;
29326 fail:
29327 return NULL;
29328 }
29329
29330
29331 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29332 PyObject *resultobj = 0;
29333
29334 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 wxWakeUpIdle();
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 resultobj = SWIG_Py_Void();
29342 return resultobj;
29343 fail:
29344 return NULL;
29345 }
29346
29347
29348 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29349 PyObject *resultobj = 0;
29350 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29351 wxEvent *arg2 = 0 ;
29352 void *argp1 = 0 ;
29353 int res1 = 0 ;
29354 void *argp2 = 0 ;
29355 int res2 = 0 ;
29356 PyObject * obj0 = 0 ;
29357 PyObject * obj1 = 0 ;
29358 char * kwnames[] = {
29359 (char *) "dest",(char *) "event", NULL
29360 };
29361
29362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29364 if (!SWIG_IsOK(res1)) {
29365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29366 }
29367 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29369 if (!SWIG_IsOK(res2)) {
29370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29371 }
29372 if (!argp2) {
29373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29374 }
29375 arg2 = reinterpret_cast< wxEvent * >(argp2);
29376 {
29377 PyThreadState* __tstate = wxPyBeginAllowThreads();
29378 wxPostEvent(arg1,*arg2);
29379 wxPyEndAllowThreads(__tstate);
29380 if (PyErr_Occurred()) SWIG_fail;
29381 }
29382 resultobj = SWIG_Py_Void();
29383 return resultobj;
29384 fail:
29385 return NULL;
29386 }
29387
29388
29389 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29390 PyObject *resultobj = 0;
29391
29392 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29393 {
29394 PyThreadState* __tstate = wxPyBeginAllowThreads();
29395 wxApp_CleanUp();
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 resultobj = SWIG_Py_Void();
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29407 PyObject *resultobj = 0;
29408 wxPyApp *result = 0 ;
29409
29410 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29411 {
29412 PyThreadState* __tstate = wxPyBeginAllowThreads();
29413 result = (wxPyApp *)wxPyGetApp();
29414 wxPyEndAllowThreads(__tstate);
29415 if (PyErr_Occurred()) SWIG_fail;
29416 }
29417 {
29418 resultobj = wxPyMake_wxObject(result, 0);
29419 }
29420 return resultobj;
29421 fail:
29422 return NULL;
29423 }
29424
29425
29426 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29427 PyObject *resultobj = 0;
29428 char *arg1 = (char *) 0 ;
29429 int res1 ;
29430 char *buf1 = 0 ;
29431 int alloc1 = 0 ;
29432 PyObject * obj0 = 0 ;
29433 char * kwnames[] = {
29434 (char *) "encoding", NULL
29435 };
29436
29437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29438 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29439 if (!SWIG_IsOK(res1)) {
29440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29441 }
29442 arg1 = buf1;
29443 {
29444 PyThreadState* __tstate = wxPyBeginAllowThreads();
29445 wxSetDefaultPyEncoding((char const *)arg1);
29446 wxPyEndAllowThreads(__tstate);
29447 if (PyErr_Occurred()) SWIG_fail;
29448 }
29449 resultobj = SWIG_Py_Void();
29450 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29451 return resultobj;
29452 fail:
29453 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29454 return NULL;
29455 }
29456
29457
29458 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 PyObject *resultobj = 0;
29460 char *result = 0 ;
29461
29462 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (char *)wxGetDefaultPyEncoding();
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 resultobj = SWIG_FromCharPtr(result);
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29477 PyObject *resultobj = 0;
29478 wxEventLoop *result = 0 ;
29479
29480 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29481 {
29482 PyThreadState* __tstate = wxPyBeginAllowThreads();
29483 result = (wxEventLoop *)new wxEventLoop();
29484 wxPyEndAllowThreads(__tstate);
29485 if (PyErr_Occurred()) SWIG_fail;
29486 }
29487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29488 return resultobj;
29489 fail:
29490 return NULL;
29491 }
29492
29493
29494 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29495 PyObject *resultobj = 0;
29496 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29497 void *argp1 = 0 ;
29498 int res1 = 0 ;
29499 PyObject *swig_obj[1] ;
29500
29501 if (!args) SWIG_fail;
29502 swig_obj[0] = args;
29503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29504 if (!SWIG_IsOK(res1)) {
29505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29506 }
29507 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29508 {
29509 PyThreadState* __tstate = wxPyBeginAllowThreads();
29510 delete arg1;
29511
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 resultobj = SWIG_Py_Void();
29516 return resultobj;
29517 fail:
29518 return NULL;
29519 }
29520
29521
29522 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29523 PyObject *resultobj = 0;
29524 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29525 int result;
29526 void *argp1 = 0 ;
29527 int res1 = 0 ;
29528 PyObject *swig_obj[1] ;
29529
29530 if (!args) SWIG_fail;
29531 swig_obj[0] = args;
29532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29533 if (!SWIG_IsOK(res1)) {
29534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29535 }
29536 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29537 {
29538 PyThreadState* __tstate = wxPyBeginAllowThreads();
29539 result = (int)(arg1)->Run();
29540 wxPyEndAllowThreads(__tstate);
29541 if (PyErr_Occurred()) SWIG_fail;
29542 }
29543 resultobj = SWIG_From_int(static_cast< int >(result));
29544 return resultobj;
29545 fail:
29546 return NULL;
29547 }
29548
29549
29550 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29551 PyObject *resultobj = 0;
29552 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29553 int arg2 = (int) 0 ;
29554 void *argp1 = 0 ;
29555 int res1 = 0 ;
29556 int val2 ;
29557 int ecode2 = 0 ;
29558 PyObject * obj0 = 0 ;
29559 PyObject * obj1 = 0 ;
29560 char * kwnames[] = {
29561 (char *) "self",(char *) "rc", NULL
29562 };
29563
29564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29566 if (!SWIG_IsOK(res1)) {
29567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29568 }
29569 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29570 if (obj1) {
29571 ecode2 = SWIG_AsVal_int(obj1, &val2);
29572 if (!SWIG_IsOK(ecode2)) {
29573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29574 }
29575 arg2 = static_cast< int >(val2);
29576 }
29577 {
29578 PyThreadState* __tstate = wxPyBeginAllowThreads();
29579 (arg1)->Exit(arg2);
29580 wxPyEndAllowThreads(__tstate);
29581 if (PyErr_Occurred()) SWIG_fail;
29582 }
29583 resultobj = SWIG_Py_Void();
29584 return resultobj;
29585 fail:
29586 return NULL;
29587 }
29588
29589
29590 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29591 PyObject *resultobj = 0;
29592 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29593 bool result;
29594 void *argp1 = 0 ;
29595 int res1 = 0 ;
29596 PyObject *swig_obj[1] ;
29597
29598 if (!args) SWIG_fail;
29599 swig_obj[0] = args;
29600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29601 if (!SWIG_IsOK(res1)) {
29602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29603 }
29604 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29605 {
29606 PyThreadState* __tstate = wxPyBeginAllowThreads();
29607 result = (bool)((wxEventLoop const *)arg1)->Pending();
29608 wxPyEndAllowThreads(__tstate);
29609 if (PyErr_Occurred()) SWIG_fail;
29610 }
29611 {
29612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29613 }
29614 return resultobj;
29615 fail:
29616 return NULL;
29617 }
29618
29619
29620 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29621 PyObject *resultobj = 0;
29622 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29623 bool result;
29624 void *argp1 = 0 ;
29625 int res1 = 0 ;
29626 PyObject *swig_obj[1] ;
29627
29628 if (!args) SWIG_fail;
29629 swig_obj[0] = args;
29630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29631 if (!SWIG_IsOK(res1)) {
29632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29633 }
29634 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29635 {
29636 PyThreadState* __tstate = wxPyBeginAllowThreads();
29637 result = (bool)(arg1)->Dispatch();
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 {
29642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29643 }
29644 return resultobj;
29645 fail:
29646 return NULL;
29647 }
29648
29649
29650 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29651 PyObject *resultobj = 0;
29652 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29653 bool result;
29654 void *argp1 = 0 ;
29655 int res1 = 0 ;
29656 PyObject *swig_obj[1] ;
29657
29658 if (!args) SWIG_fail;
29659 swig_obj[0] = args;
29660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29661 if (!SWIG_IsOK(res1)) {
29662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29663 }
29664 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29665 {
29666 PyThreadState* __tstate = wxPyBeginAllowThreads();
29667 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29668 wxPyEndAllowThreads(__tstate);
29669 if (PyErr_Occurred()) SWIG_fail;
29670 }
29671 {
29672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29673 }
29674 return resultobj;
29675 fail:
29676 return NULL;
29677 }
29678
29679
29680 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29681 PyObject *resultobj = 0;
29682 wxEventLoop *result = 0 ;
29683
29684 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29685 {
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 result = (wxEventLoop *)wxEventLoop::GetActive();
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29692 return resultobj;
29693 fail:
29694 return NULL;
29695 }
29696
29697
29698 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29699 PyObject *resultobj = 0;
29700 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29701 void *argp1 = 0 ;
29702 int res1 = 0 ;
29703 PyObject * obj0 = 0 ;
29704 char * kwnames[] = {
29705 (char *) "loop", NULL
29706 };
29707
29708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29710 if (!SWIG_IsOK(res1)) {
29711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29712 }
29713 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29714 {
29715 PyThreadState* __tstate = wxPyBeginAllowThreads();
29716 wxEventLoop::SetActive(arg1);
29717 wxPyEndAllowThreads(__tstate);
29718 if (PyErr_Occurred()) SWIG_fail;
29719 }
29720 resultobj = SWIG_Py_Void();
29721 return resultobj;
29722 fail:
29723 return NULL;
29724 }
29725
29726
29727 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29728 PyObject *obj;
29729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29730 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29731 return SWIG_Py_Void();
29732 }
29733
29734 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29735 return SWIG_Python_InitShadowInstance(args);
29736 }
29737
29738 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29739 PyObject *resultobj = 0;
29740 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29741 wxEventLoopActivator *result = 0 ;
29742 void *argp1 = 0 ;
29743 int res1 = 0 ;
29744 PyObject * obj0 = 0 ;
29745 char * kwnames[] = {
29746 (char *) "evtLoop", NULL
29747 };
29748
29749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29751 if (!SWIG_IsOK(res1)) {
29752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29753 }
29754 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29755 {
29756 PyThreadState* __tstate = wxPyBeginAllowThreads();
29757 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29758 wxPyEndAllowThreads(__tstate);
29759 if (PyErr_Occurred()) SWIG_fail;
29760 }
29761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29762 return resultobj;
29763 fail:
29764 return NULL;
29765 }
29766
29767
29768 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29769 PyObject *resultobj = 0;
29770 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29771 void *argp1 = 0 ;
29772 int res1 = 0 ;
29773 PyObject *swig_obj[1] ;
29774
29775 if (!args) SWIG_fail;
29776 swig_obj[0] = args;
29777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29778 if (!SWIG_IsOK(res1)) {
29779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29780 }
29781 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29782 {
29783 PyThreadState* __tstate = wxPyBeginAllowThreads();
29784 delete arg1;
29785
29786 wxPyEndAllowThreads(__tstate);
29787 if (PyErr_Occurred()) SWIG_fail;
29788 }
29789 resultobj = SWIG_Py_Void();
29790 return resultobj;
29791 fail:
29792 return NULL;
29793 }
29794
29795
29796 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29797 PyObject *obj;
29798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29799 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29800 return SWIG_Py_Void();
29801 }
29802
29803 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29804 return SWIG_Python_InitShadowInstance(args);
29805 }
29806
29807 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29808 PyObject *resultobj = 0;
29809 int arg1 = (int) 0 ;
29810 int arg2 = (int) 0 ;
29811 int arg3 = (int) 0 ;
29812 wxAcceleratorEntry *result = 0 ;
29813 int val1 ;
29814 int ecode1 = 0 ;
29815 int val2 ;
29816 int ecode2 = 0 ;
29817 int val3 ;
29818 int ecode3 = 0 ;
29819 PyObject * obj0 = 0 ;
29820 PyObject * obj1 = 0 ;
29821 PyObject * obj2 = 0 ;
29822 char * kwnames[] = {
29823 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29824 };
29825
29826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29827 if (obj0) {
29828 ecode1 = SWIG_AsVal_int(obj0, &val1);
29829 if (!SWIG_IsOK(ecode1)) {
29830 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29831 }
29832 arg1 = static_cast< int >(val1);
29833 }
29834 if (obj1) {
29835 ecode2 = SWIG_AsVal_int(obj1, &val2);
29836 if (!SWIG_IsOK(ecode2)) {
29837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29838 }
29839 arg2 = static_cast< int >(val2);
29840 }
29841 if (obj2) {
29842 ecode3 = SWIG_AsVal_int(obj2, &val3);
29843 if (!SWIG_IsOK(ecode3)) {
29844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29845 }
29846 arg3 = static_cast< int >(val3);
29847 }
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29855 return resultobj;
29856 fail:
29857 return NULL;
29858 }
29859
29860
29861 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29862 PyObject *resultobj = 0;
29863 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29864 void *argp1 = 0 ;
29865 int res1 = 0 ;
29866 PyObject *swig_obj[1] ;
29867
29868 if (!args) SWIG_fail;
29869 swig_obj[0] = args;
29870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29871 if (!SWIG_IsOK(res1)) {
29872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29873 }
29874 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29875 {
29876 PyThreadState* __tstate = wxPyBeginAllowThreads();
29877 delete arg1;
29878
29879 wxPyEndAllowThreads(__tstate);
29880 if (PyErr_Occurred()) SWIG_fail;
29881 }
29882 resultobj = SWIG_Py_Void();
29883 return resultobj;
29884 fail:
29885 return NULL;
29886 }
29887
29888
29889 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29890 PyObject *resultobj = 0;
29891 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29892 int arg2 ;
29893 int arg3 ;
29894 int arg4 ;
29895 void *argp1 = 0 ;
29896 int res1 = 0 ;
29897 int val2 ;
29898 int ecode2 = 0 ;
29899 int val3 ;
29900 int ecode3 = 0 ;
29901 int val4 ;
29902 int ecode4 = 0 ;
29903 PyObject * obj0 = 0 ;
29904 PyObject * obj1 = 0 ;
29905 PyObject * obj2 = 0 ;
29906 PyObject * obj3 = 0 ;
29907 char * kwnames[] = {
29908 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29909 };
29910
29911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29913 if (!SWIG_IsOK(res1)) {
29914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29915 }
29916 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29917 ecode2 = SWIG_AsVal_int(obj1, &val2);
29918 if (!SWIG_IsOK(ecode2)) {
29919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29920 }
29921 arg2 = static_cast< int >(val2);
29922 ecode3 = SWIG_AsVal_int(obj2, &val3);
29923 if (!SWIG_IsOK(ecode3)) {
29924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29925 }
29926 arg3 = static_cast< int >(val3);
29927 ecode4 = SWIG_AsVal_int(obj3, &val4);
29928 if (!SWIG_IsOK(ecode4)) {
29929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29930 }
29931 arg4 = static_cast< int >(val4);
29932 {
29933 PyThreadState* __tstate = wxPyBeginAllowThreads();
29934 (arg1)->Set(arg2,arg3,arg4);
29935 wxPyEndAllowThreads(__tstate);
29936 if (PyErr_Occurred()) SWIG_fail;
29937 }
29938 resultobj = SWIG_Py_Void();
29939 return resultobj;
29940 fail:
29941 return NULL;
29942 }
29943
29944
29945 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29946 PyObject *resultobj = 0;
29947 wxString *arg1 = 0 ;
29948 wxAcceleratorEntry *result = 0 ;
29949 bool temp1 = false ;
29950 PyObject * obj0 = 0 ;
29951 char * kwnames[] = {
29952 (char *) "str", NULL
29953 };
29954
29955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29956 {
29957 arg1 = wxString_in_helper(obj0);
29958 if (arg1 == NULL) SWIG_fail;
29959 temp1 = true;
29960 }
29961 {
29962 PyThreadState* __tstate = wxPyBeginAllowThreads();
29963 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29964 wxPyEndAllowThreads(__tstate);
29965 if (PyErr_Occurred()) SWIG_fail;
29966 }
29967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29968 {
29969 if (temp1)
29970 delete arg1;
29971 }
29972 return resultobj;
29973 fail:
29974 {
29975 if (temp1)
29976 delete arg1;
29977 }
29978 return NULL;
29979 }
29980
29981
29982 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29983 PyObject *resultobj = 0;
29984 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29985 int result;
29986 void *argp1 = 0 ;
29987 int res1 = 0 ;
29988 PyObject *swig_obj[1] ;
29989
29990 if (!args) SWIG_fail;
29991 swig_obj[0] = args;
29992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29993 if (!SWIG_IsOK(res1)) {
29994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29995 }
29996 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29997 {
29998 PyThreadState* __tstate = wxPyBeginAllowThreads();
29999 result = (int)(arg1)->GetFlags();
30000 wxPyEndAllowThreads(__tstate);
30001 if (PyErr_Occurred()) SWIG_fail;
30002 }
30003 resultobj = SWIG_From_int(static_cast< int >(result));
30004 return resultobj;
30005 fail:
30006 return NULL;
30007 }
30008
30009
30010 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30011 PyObject *resultobj = 0;
30012 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30013 int result;
30014 void *argp1 = 0 ;
30015 int res1 = 0 ;
30016 PyObject *swig_obj[1] ;
30017
30018 if (!args) SWIG_fail;
30019 swig_obj[0] = args;
30020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30021 if (!SWIG_IsOK(res1)) {
30022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30023 }
30024 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30025 {
30026 PyThreadState* __tstate = wxPyBeginAllowThreads();
30027 result = (int)(arg1)->GetKeyCode();
30028 wxPyEndAllowThreads(__tstate);
30029 if (PyErr_Occurred()) SWIG_fail;
30030 }
30031 resultobj = SWIG_From_int(static_cast< int >(result));
30032 return resultobj;
30033 fail:
30034 return NULL;
30035 }
30036
30037
30038 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30039 PyObject *resultobj = 0;
30040 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30041 int result;
30042 void *argp1 = 0 ;
30043 int res1 = 0 ;
30044 PyObject *swig_obj[1] ;
30045
30046 if (!args) SWIG_fail;
30047 swig_obj[0] = args;
30048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30049 if (!SWIG_IsOK(res1)) {
30050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30051 }
30052 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30053 {
30054 PyThreadState* __tstate = wxPyBeginAllowThreads();
30055 result = (int)(arg1)->GetCommand();
30056 wxPyEndAllowThreads(__tstate);
30057 if (PyErr_Occurred()) SWIG_fail;
30058 }
30059 resultobj = SWIG_From_int(static_cast< int >(result));
30060 return resultobj;
30061 fail:
30062 return NULL;
30063 }
30064
30065
30066 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30067 PyObject *resultobj = 0;
30068 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30069 bool result;
30070 void *argp1 = 0 ;
30071 int res1 = 0 ;
30072 PyObject *swig_obj[1] ;
30073
30074 if (!args) SWIG_fail;
30075 swig_obj[0] = args;
30076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30077 if (!SWIG_IsOK(res1)) {
30078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30079 }
30080 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30081 {
30082 PyThreadState* __tstate = wxPyBeginAllowThreads();
30083 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
30084 wxPyEndAllowThreads(__tstate);
30085 if (PyErr_Occurred()) SWIG_fail;
30086 }
30087 {
30088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30089 }
30090 return resultobj;
30091 fail:
30092 return NULL;
30093 }
30094
30095
30096 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30097 PyObject *resultobj = 0;
30098 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30099 wxString result;
30100 void *argp1 = 0 ;
30101 int res1 = 0 ;
30102 PyObject *swig_obj[1] ;
30103
30104 if (!args) SWIG_fail;
30105 swig_obj[0] = args;
30106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30107 if (!SWIG_IsOK(res1)) {
30108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30109 }
30110 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30111 {
30112 PyThreadState* __tstate = wxPyBeginAllowThreads();
30113 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30114 wxPyEndAllowThreads(__tstate);
30115 if (PyErr_Occurred()) SWIG_fail;
30116 }
30117 {
30118 #if wxUSE_UNICODE
30119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30120 #else
30121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30122 #endif
30123 }
30124 return resultobj;
30125 fail:
30126 return NULL;
30127 }
30128
30129
30130 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30131 PyObject *resultobj = 0;
30132 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30133 wxString *arg2 = 0 ;
30134 bool result;
30135 void *argp1 = 0 ;
30136 int res1 = 0 ;
30137 bool temp2 = false ;
30138 PyObject * obj0 = 0 ;
30139 PyObject * obj1 = 0 ;
30140 char * kwnames[] = {
30141 (char *) "self",(char *) "str", NULL
30142 };
30143
30144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30146 if (!SWIG_IsOK(res1)) {
30147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30148 }
30149 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30150 {
30151 arg2 = wxString_in_helper(obj1);
30152 if (arg2 == NULL) SWIG_fail;
30153 temp2 = true;
30154 }
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 {
30162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30163 }
30164 {
30165 if (temp2)
30166 delete arg2;
30167 }
30168 return resultobj;
30169 fail:
30170 {
30171 if (temp2)
30172 delete arg2;
30173 }
30174 return NULL;
30175 }
30176
30177
30178 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30179 PyObject *obj;
30180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30181 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30182 return SWIG_Py_Void();
30183 }
30184
30185 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30186 return SWIG_Python_InitShadowInstance(args);
30187 }
30188
30189 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30190 PyObject *resultobj = 0;
30191 int arg1 ;
30192 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30193 wxAcceleratorTable *result = 0 ;
30194 PyObject * obj0 = 0 ;
30195 char * kwnames[] = {
30196 (char *) "n", NULL
30197 };
30198
30199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30200 {
30201 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30202 if (arg2) arg1 = PyList_Size(obj0);
30203 else arg1 = 0;
30204 }
30205 {
30206 PyThreadState* __tstate = wxPyBeginAllowThreads();
30207 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30208 wxPyEndAllowThreads(__tstate);
30209 if (PyErr_Occurred()) SWIG_fail;
30210 }
30211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30212 return resultobj;
30213 fail:
30214 return NULL;
30215 }
30216
30217
30218 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30219 PyObject *resultobj = 0;
30220 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30221 void *argp1 = 0 ;
30222 int res1 = 0 ;
30223 PyObject *swig_obj[1] ;
30224
30225 if (!args) SWIG_fail;
30226 swig_obj[0] = args;
30227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30228 if (!SWIG_IsOK(res1)) {
30229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30230 }
30231 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30232 {
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 delete arg1;
30235
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 resultobj = SWIG_Py_Void();
30240 return resultobj;
30241 fail:
30242 return NULL;
30243 }
30244
30245
30246 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30247 PyObject *resultobj = 0;
30248 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30249 bool result;
30250 void *argp1 = 0 ;
30251 int res1 = 0 ;
30252 PyObject *swig_obj[1] ;
30253
30254 if (!args) SWIG_fail;
30255 swig_obj[0] = args;
30256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30257 if (!SWIG_IsOK(res1)) {
30258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30259 }
30260 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30261 {
30262 PyThreadState* __tstate = wxPyBeginAllowThreads();
30263 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
30264 wxPyEndAllowThreads(__tstate);
30265 if (PyErr_Occurred()) SWIG_fail;
30266 }
30267 {
30268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30269 }
30270 return resultobj;
30271 fail:
30272 return NULL;
30273 }
30274
30275
30276 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30277 PyObject *obj;
30278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30279 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30280 return SWIG_Py_Void();
30281 }
30282
30283 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30284 return SWIG_Python_InitShadowInstance(args);
30285 }
30286
30287 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30288 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30289 return 1;
30290 }
30291
30292
30293 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30294 PyObject *pyobj = 0;
30295
30296 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30297 return pyobj;
30298 }
30299
30300
30301 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30302 PyObject *resultobj = 0;
30303 wxString *arg1 = 0 ;
30304 wxAcceleratorEntry *result = 0 ;
30305 bool temp1 = false ;
30306 PyObject * obj0 = 0 ;
30307 char * kwnames[] = {
30308 (char *) "label", NULL
30309 };
30310
30311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30312 {
30313 arg1 = wxString_in_helper(obj0);
30314 if (arg1 == NULL) SWIG_fail;
30315 temp1 = true;
30316 }
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30320 wxPyEndAllowThreads(__tstate);
30321 if (PyErr_Occurred()) SWIG_fail;
30322 }
30323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30324 {
30325 if (temp1)
30326 delete arg1;
30327 }
30328 return resultobj;
30329 fail:
30330 {
30331 if (temp1)
30332 delete arg1;
30333 }
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN int PanelNameStr_set(PyObject *) {
30339 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30340 return 1;
30341 }
30342
30343
30344 SWIGINTERN PyObject *PanelNameStr_get(void) {
30345 PyObject *pyobj = 0;
30346
30347 {
30348 #if wxUSE_UNICODE
30349 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30350 #else
30351 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30352 #endif
30353 }
30354 return pyobj;
30355 }
30356
30357
30358 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30359 PyObject *resultobj = 0;
30360 wxVisualAttributes *result = 0 ;
30361
30362 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = (wxVisualAttributes *)new_wxVisualAttributes();
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30370 return resultobj;
30371 fail:
30372 return NULL;
30373 }
30374
30375
30376 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30377 PyObject *resultobj = 0;
30378 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30379 void *argp1 = 0 ;
30380 int res1 = 0 ;
30381 PyObject *swig_obj[1] ;
30382
30383 if (!args) SWIG_fail;
30384 swig_obj[0] = args;
30385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30386 if (!SWIG_IsOK(res1)) {
30387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30388 }
30389 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30390 {
30391 PyThreadState* __tstate = wxPyBeginAllowThreads();
30392 delete_wxVisualAttributes(arg1);
30393
30394 wxPyEndAllowThreads(__tstate);
30395 if (PyErr_Occurred()) SWIG_fail;
30396 }
30397 resultobj = SWIG_Py_Void();
30398 return resultobj;
30399 fail:
30400 return NULL;
30401 }
30402
30403
30404 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30405 PyObject *resultobj = 0;
30406 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30407 wxFont *arg2 = (wxFont *) 0 ;
30408 void *argp1 = 0 ;
30409 int res1 = 0 ;
30410 void *argp2 = 0 ;
30411 int res2 = 0 ;
30412 PyObject *swig_obj[2] ;
30413
30414 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30416 if (!SWIG_IsOK(res1)) {
30417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30418 }
30419 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30420 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30421 if (!SWIG_IsOK(res2)) {
30422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30423 }
30424 arg2 = reinterpret_cast< wxFont * >(argp2);
30425 if (arg1) (arg1)->font = *arg2;
30426
30427 resultobj = SWIG_Py_Void();
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30435 PyObject *resultobj = 0;
30436 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30437 wxFont *result = 0 ;
30438 void *argp1 = 0 ;
30439 int res1 = 0 ;
30440 PyObject *swig_obj[1] ;
30441
30442 if (!args) SWIG_fail;
30443 swig_obj[0] = args;
30444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30445 if (!SWIG_IsOK(res1)) {
30446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30447 }
30448 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30449 result = (wxFont *)& ((arg1)->font);
30450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30458 PyObject *resultobj = 0;
30459 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30460 wxColour *arg2 = (wxColour *) 0 ;
30461 void *argp1 = 0 ;
30462 int res1 = 0 ;
30463 void *argp2 = 0 ;
30464 int res2 = 0 ;
30465 PyObject *swig_obj[2] ;
30466
30467 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30469 if (!SWIG_IsOK(res1)) {
30470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30471 }
30472 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30473 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30474 if (!SWIG_IsOK(res2)) {
30475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30476 }
30477 arg2 = reinterpret_cast< wxColour * >(argp2);
30478 if (arg1) (arg1)->colFg = *arg2;
30479
30480 resultobj = SWIG_Py_Void();
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30488 PyObject *resultobj = 0;
30489 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30490 wxColour *result = 0 ;
30491 void *argp1 = 0 ;
30492 int res1 = 0 ;
30493 PyObject *swig_obj[1] ;
30494
30495 if (!args) SWIG_fail;
30496 swig_obj[0] = args;
30497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30498 if (!SWIG_IsOK(res1)) {
30499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30500 }
30501 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30502 result = (wxColour *)& ((arg1)->colFg);
30503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30511 PyObject *resultobj = 0;
30512 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30513 wxColour *arg2 = (wxColour *) 0 ;
30514 void *argp1 = 0 ;
30515 int res1 = 0 ;
30516 void *argp2 = 0 ;
30517 int res2 = 0 ;
30518 PyObject *swig_obj[2] ;
30519
30520 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30522 if (!SWIG_IsOK(res1)) {
30523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30524 }
30525 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30526 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30527 if (!SWIG_IsOK(res2)) {
30528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30529 }
30530 arg2 = reinterpret_cast< wxColour * >(argp2);
30531 if (arg1) (arg1)->colBg = *arg2;
30532
30533 resultobj = SWIG_Py_Void();
30534 return resultobj;
30535 fail:
30536 return NULL;
30537 }
30538
30539
30540 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30541 PyObject *resultobj = 0;
30542 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30543 wxColour *result = 0 ;
30544 void *argp1 = 0 ;
30545 int res1 = 0 ;
30546 PyObject *swig_obj[1] ;
30547
30548 if (!args) SWIG_fail;
30549 swig_obj[0] = args;
30550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30551 if (!SWIG_IsOK(res1)) {
30552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30553 }
30554 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30555 result = (wxColour *)& ((arg1)->colBg);
30556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30557 return resultobj;
30558 fail:
30559 return NULL;
30560 }
30561
30562
30563 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30564 PyObject *obj;
30565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30566 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30567 return SWIG_Py_Void();
30568 }
30569
30570 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30571 return SWIG_Python_InitShadowInstance(args);
30572 }
30573
30574 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30575 PyObject *resultobj = 0;
30576 wxWindow *arg1 = (wxWindow *) 0 ;
30577 int arg2 = (int) (int)-1 ;
30578 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30579 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30580 wxSize const &arg4_defvalue = wxDefaultSize ;
30581 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30582 long arg5 = (long) 0 ;
30583 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30584 wxString *arg6 = (wxString *) &arg6_defvalue ;
30585 wxWindow *result = 0 ;
30586 void *argp1 = 0 ;
30587 int res1 = 0 ;
30588 int val2 ;
30589 int ecode2 = 0 ;
30590 wxPoint temp3 ;
30591 wxSize temp4 ;
30592 long val5 ;
30593 int ecode5 = 0 ;
30594 bool temp6 = false ;
30595 PyObject * obj0 = 0 ;
30596 PyObject * obj1 = 0 ;
30597 PyObject * obj2 = 0 ;
30598 PyObject * obj3 = 0 ;
30599 PyObject * obj4 = 0 ;
30600 PyObject * obj5 = 0 ;
30601 char * kwnames[] = {
30602 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30603 };
30604
30605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30607 if (!SWIG_IsOK(res1)) {
30608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30609 }
30610 arg1 = reinterpret_cast< wxWindow * >(argp1);
30611 if (obj1) {
30612 ecode2 = SWIG_AsVal_int(obj1, &val2);
30613 if (!SWIG_IsOK(ecode2)) {
30614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30615 }
30616 arg2 = static_cast< int >(val2);
30617 }
30618 if (obj2) {
30619 {
30620 arg3 = &temp3;
30621 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30622 }
30623 }
30624 if (obj3) {
30625 {
30626 arg4 = &temp4;
30627 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30628 }
30629 }
30630 if (obj4) {
30631 ecode5 = SWIG_AsVal_long(obj4, &val5);
30632 if (!SWIG_IsOK(ecode5)) {
30633 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30634 }
30635 arg5 = static_cast< long >(val5);
30636 }
30637 if (obj5) {
30638 {
30639 arg6 = wxString_in_helper(obj5);
30640 if (arg6 == NULL) SWIG_fail;
30641 temp6 = true;
30642 }
30643 }
30644 {
30645 if (!wxPyCheckForApp()) SWIG_fail;
30646 PyThreadState* __tstate = wxPyBeginAllowThreads();
30647 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30652 {
30653 if (temp6)
30654 delete arg6;
30655 }
30656 return resultobj;
30657 fail:
30658 {
30659 if (temp6)
30660 delete arg6;
30661 }
30662 return NULL;
30663 }
30664
30665
30666 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30667 PyObject *resultobj = 0;
30668 wxWindow *result = 0 ;
30669
30670 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30671 {
30672 if (!wxPyCheckForApp()) SWIG_fail;
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 result = (wxWindow *)new wxWindow();
30675 wxPyEndAllowThreads(__tstate);
30676 if (PyErr_Occurred()) SWIG_fail;
30677 }
30678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30679 return resultobj;
30680 fail:
30681 return NULL;
30682 }
30683
30684
30685 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30686 PyObject *resultobj = 0;
30687 wxWindow *arg1 = (wxWindow *) 0 ;
30688 wxWindow *arg2 = (wxWindow *) 0 ;
30689 int arg3 = (int) (int)-1 ;
30690 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30691 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30692 wxSize const &arg5_defvalue = wxDefaultSize ;
30693 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30694 long arg6 = (long) 0 ;
30695 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30696 wxString *arg7 = (wxString *) &arg7_defvalue ;
30697 bool result;
30698 void *argp1 = 0 ;
30699 int res1 = 0 ;
30700 void *argp2 = 0 ;
30701 int res2 = 0 ;
30702 int val3 ;
30703 int ecode3 = 0 ;
30704 wxPoint temp4 ;
30705 wxSize temp5 ;
30706 long val6 ;
30707 int ecode6 = 0 ;
30708 bool temp7 = false ;
30709 PyObject * obj0 = 0 ;
30710 PyObject * obj1 = 0 ;
30711 PyObject * obj2 = 0 ;
30712 PyObject * obj3 = 0 ;
30713 PyObject * obj4 = 0 ;
30714 PyObject * obj5 = 0 ;
30715 PyObject * obj6 = 0 ;
30716 char * kwnames[] = {
30717 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30718 };
30719
30720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30722 if (!SWIG_IsOK(res1)) {
30723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30724 }
30725 arg1 = reinterpret_cast< wxWindow * >(argp1);
30726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30727 if (!SWIG_IsOK(res2)) {
30728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30729 }
30730 arg2 = reinterpret_cast< wxWindow * >(argp2);
30731 if (obj2) {
30732 ecode3 = SWIG_AsVal_int(obj2, &val3);
30733 if (!SWIG_IsOK(ecode3)) {
30734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30735 }
30736 arg3 = static_cast< int >(val3);
30737 }
30738 if (obj3) {
30739 {
30740 arg4 = &temp4;
30741 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30742 }
30743 }
30744 if (obj4) {
30745 {
30746 arg5 = &temp5;
30747 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30748 }
30749 }
30750 if (obj5) {
30751 ecode6 = SWIG_AsVal_long(obj5, &val6);
30752 if (!SWIG_IsOK(ecode6)) {
30753 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30754 }
30755 arg6 = static_cast< long >(val6);
30756 }
30757 if (obj6) {
30758 {
30759 arg7 = wxString_in_helper(obj6);
30760 if (arg7 == NULL) SWIG_fail;
30761 temp7 = true;
30762 }
30763 }
30764 {
30765 PyThreadState* __tstate = wxPyBeginAllowThreads();
30766 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30767 wxPyEndAllowThreads(__tstate);
30768 if (PyErr_Occurred()) SWIG_fail;
30769 }
30770 {
30771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30772 }
30773 {
30774 if (temp7)
30775 delete arg7;
30776 }
30777 return resultobj;
30778 fail:
30779 {
30780 if (temp7)
30781 delete arg7;
30782 }
30783 return NULL;
30784 }
30785
30786
30787 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30788 PyObject *resultobj = 0;
30789 wxWindow *arg1 = (wxWindow *) 0 ;
30790 bool arg2 = (bool) false ;
30791 bool result;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 bool val2 ;
30795 int ecode2 = 0 ;
30796 PyObject * obj0 = 0 ;
30797 PyObject * obj1 = 0 ;
30798 char * kwnames[] = {
30799 (char *) "self",(char *) "force", NULL
30800 };
30801
30802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30804 if (!SWIG_IsOK(res1)) {
30805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30806 }
30807 arg1 = reinterpret_cast< wxWindow * >(argp1);
30808 if (obj1) {
30809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30810 if (!SWIG_IsOK(ecode2)) {
30811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30812 }
30813 arg2 = static_cast< bool >(val2);
30814 }
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 result = (bool)(arg1)->Close(arg2);
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 {
30822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30823 }
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30831 PyObject *resultobj = 0;
30832 wxWindow *arg1 = (wxWindow *) 0 ;
30833 bool result;
30834 void *argp1 = 0 ;
30835 int res1 = 0 ;
30836 PyObject *swig_obj[1] ;
30837
30838 if (!args) SWIG_fail;
30839 swig_obj[0] = args;
30840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30841 if (!SWIG_IsOK(res1)) {
30842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30843 }
30844 arg1 = reinterpret_cast< wxWindow * >(argp1);
30845 {
30846 PyThreadState* __tstate = wxPyBeginAllowThreads();
30847 result = (bool)(arg1)->Destroy();
30848 wxPyEndAllowThreads(__tstate);
30849 if (PyErr_Occurred()) SWIG_fail;
30850 }
30851 {
30852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30853 }
30854 return resultobj;
30855 fail:
30856 return NULL;
30857 }
30858
30859
30860 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30861 PyObject *resultobj = 0;
30862 wxWindow *arg1 = (wxWindow *) 0 ;
30863 bool result;
30864 void *argp1 = 0 ;
30865 int res1 = 0 ;
30866 PyObject *swig_obj[1] ;
30867
30868 if (!args) SWIG_fail;
30869 swig_obj[0] = args;
30870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30871 if (!SWIG_IsOK(res1)) {
30872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30873 }
30874 arg1 = reinterpret_cast< wxWindow * >(argp1);
30875 {
30876 PyThreadState* __tstate = wxPyBeginAllowThreads();
30877 result = (bool)(arg1)->DestroyChildren();
30878 wxPyEndAllowThreads(__tstate);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 }
30881 {
30882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30883 }
30884 return resultobj;
30885 fail:
30886 return NULL;
30887 }
30888
30889
30890 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30891 PyObject *resultobj = 0;
30892 wxWindow *arg1 = (wxWindow *) 0 ;
30893 bool result;
30894 void *argp1 = 0 ;
30895 int res1 = 0 ;
30896 PyObject *swig_obj[1] ;
30897
30898 if (!args) SWIG_fail;
30899 swig_obj[0] = args;
30900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30901 if (!SWIG_IsOK(res1)) {
30902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30903 }
30904 arg1 = reinterpret_cast< wxWindow * >(argp1);
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30908 wxPyEndAllowThreads(__tstate);
30909 if (PyErr_Occurred()) SWIG_fail;
30910 }
30911 {
30912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30913 }
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30921 PyObject *resultobj = 0;
30922 wxWindow *arg1 = (wxWindow *) 0 ;
30923 wxString *arg2 = 0 ;
30924 void *argp1 = 0 ;
30925 int res1 = 0 ;
30926 bool temp2 = false ;
30927 PyObject * obj0 = 0 ;
30928 PyObject * obj1 = 0 ;
30929 char * kwnames[] = {
30930 (char *) "self",(char *) "label", NULL
30931 };
30932
30933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30935 if (!SWIG_IsOK(res1)) {
30936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30937 }
30938 arg1 = reinterpret_cast< wxWindow * >(argp1);
30939 {
30940 arg2 = wxString_in_helper(obj1);
30941 if (arg2 == NULL) SWIG_fail;
30942 temp2 = true;
30943 }
30944 {
30945 PyThreadState* __tstate = wxPyBeginAllowThreads();
30946 (arg1)->SetLabel((wxString const &)*arg2);
30947 wxPyEndAllowThreads(__tstate);
30948 if (PyErr_Occurred()) SWIG_fail;
30949 }
30950 resultobj = SWIG_Py_Void();
30951 {
30952 if (temp2)
30953 delete arg2;
30954 }
30955 return resultobj;
30956 fail:
30957 {
30958 if (temp2)
30959 delete arg2;
30960 }
30961 return NULL;
30962 }
30963
30964
30965 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30966 PyObject *resultobj = 0;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 wxString result;
30969 void *argp1 = 0 ;
30970 int res1 = 0 ;
30971 PyObject *swig_obj[1] ;
30972
30973 if (!args) SWIG_fail;
30974 swig_obj[0] = args;
30975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30976 if (!SWIG_IsOK(res1)) {
30977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30978 }
30979 arg1 = reinterpret_cast< wxWindow * >(argp1);
30980 {
30981 PyThreadState* __tstate = wxPyBeginAllowThreads();
30982 result = ((wxWindow const *)arg1)->GetLabel();
30983 wxPyEndAllowThreads(__tstate);
30984 if (PyErr_Occurred()) SWIG_fail;
30985 }
30986 {
30987 #if wxUSE_UNICODE
30988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30989 #else
30990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30991 #endif
30992 }
30993 return resultobj;
30994 fail:
30995 return NULL;
30996 }
30997
30998
30999 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31000 PyObject *resultobj = 0;
31001 wxWindow *arg1 = (wxWindow *) 0 ;
31002 wxString *arg2 = 0 ;
31003 void *argp1 = 0 ;
31004 int res1 = 0 ;
31005 bool temp2 = false ;
31006 PyObject * obj0 = 0 ;
31007 PyObject * obj1 = 0 ;
31008 char * kwnames[] = {
31009 (char *) "self",(char *) "name", NULL
31010 };
31011
31012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
31013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31014 if (!SWIG_IsOK(res1)) {
31015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
31016 }
31017 arg1 = reinterpret_cast< wxWindow * >(argp1);
31018 {
31019 arg2 = wxString_in_helper(obj1);
31020 if (arg2 == NULL) SWIG_fail;
31021 temp2 = true;
31022 }
31023 {
31024 PyThreadState* __tstate = wxPyBeginAllowThreads();
31025 (arg1)->SetName((wxString const &)*arg2);
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 resultobj = SWIG_Py_Void();
31030 {
31031 if (temp2)
31032 delete arg2;
31033 }
31034 return resultobj;
31035 fail:
31036 {
31037 if (temp2)
31038 delete arg2;
31039 }
31040 return NULL;
31041 }
31042
31043
31044 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31045 PyObject *resultobj = 0;
31046 wxWindow *arg1 = (wxWindow *) 0 ;
31047 wxString result;
31048 void *argp1 = 0 ;
31049 int res1 = 0 ;
31050 PyObject *swig_obj[1] ;
31051
31052 if (!args) SWIG_fail;
31053 swig_obj[0] = args;
31054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31055 if (!SWIG_IsOK(res1)) {
31056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
31057 }
31058 arg1 = reinterpret_cast< wxWindow * >(argp1);
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 result = ((wxWindow const *)arg1)->GetName();
31062 wxPyEndAllowThreads(__tstate);
31063 if (PyErr_Occurred()) SWIG_fail;
31064 }
31065 {
31066 #if wxUSE_UNICODE
31067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31068 #else
31069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31070 #endif
31071 }
31072 return resultobj;
31073 fail:
31074 return NULL;
31075 }
31076
31077
31078 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31079 PyObject *resultobj = 0;
31080 wxWindow *arg1 = (wxWindow *) 0 ;
31081 wxWindowVariant arg2 ;
31082 void *argp1 = 0 ;
31083 int res1 = 0 ;
31084 int val2 ;
31085 int ecode2 = 0 ;
31086 PyObject * obj0 = 0 ;
31087 PyObject * obj1 = 0 ;
31088 char * kwnames[] = {
31089 (char *) "self",(char *) "variant", NULL
31090 };
31091
31092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
31093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31094 if (!SWIG_IsOK(res1)) {
31095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
31096 }
31097 arg1 = reinterpret_cast< wxWindow * >(argp1);
31098 ecode2 = SWIG_AsVal_int(obj1, &val2);
31099 if (!SWIG_IsOK(ecode2)) {
31100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
31101 }
31102 arg2 = static_cast< wxWindowVariant >(val2);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 (arg1)->SetWindowVariant(arg2);
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 resultobj = SWIG_Py_Void();
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31117 PyObject *resultobj = 0;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxWindowVariant result;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 PyObject *swig_obj[1] ;
31123
31124 if (!args) SWIG_fail;
31125 swig_obj[0] = args;
31126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31127 if (!SWIG_IsOK(res1)) {
31128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31129 }
31130 arg1 = reinterpret_cast< wxWindow * >(argp1);
31131 {
31132 PyThreadState* __tstate = wxPyBeginAllowThreads();
31133 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 resultobj = SWIG_From_int(static_cast< int >(result));
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31145 PyObject *resultobj = 0;
31146 wxWindow *arg1 = (wxWindow *) 0 ;
31147 int arg2 ;
31148 void *argp1 = 0 ;
31149 int res1 = 0 ;
31150 int val2 ;
31151 int ecode2 = 0 ;
31152 PyObject * obj0 = 0 ;
31153 PyObject * obj1 = 0 ;
31154 char * kwnames[] = {
31155 (char *) "self",(char *) "winid", NULL
31156 };
31157
31158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31160 if (!SWIG_IsOK(res1)) {
31161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31162 }
31163 arg1 = reinterpret_cast< wxWindow * >(argp1);
31164 ecode2 = SWIG_AsVal_int(obj1, &val2);
31165 if (!SWIG_IsOK(ecode2)) {
31166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31167 }
31168 arg2 = static_cast< int >(val2);
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 (arg1)->SetId(arg2);
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 resultobj = SWIG_Py_Void();
31176 return resultobj;
31177 fail:
31178 return NULL;
31179 }
31180
31181
31182 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31183 PyObject *resultobj = 0;
31184 wxWindow *arg1 = (wxWindow *) 0 ;
31185 int result;
31186 void *argp1 = 0 ;
31187 int res1 = 0 ;
31188 PyObject *swig_obj[1] ;
31189
31190 if (!args) SWIG_fail;
31191 swig_obj[0] = args;
31192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31193 if (!SWIG_IsOK(res1)) {
31194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31195 }
31196 arg1 = reinterpret_cast< wxWindow * >(argp1);
31197 {
31198 PyThreadState* __tstate = wxPyBeginAllowThreads();
31199 result = (int)((wxWindow const *)arg1)->GetId();
31200 wxPyEndAllowThreads(__tstate);
31201 if (PyErr_Occurred()) SWIG_fail;
31202 }
31203 resultobj = SWIG_From_int(static_cast< int >(result));
31204 return resultobj;
31205 fail:
31206 return NULL;
31207 }
31208
31209
31210 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31211 PyObject *resultobj = 0;
31212 int result;
31213
31214 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31215 {
31216 PyThreadState* __tstate = wxPyBeginAllowThreads();
31217 result = (int)wxWindow::NewControlId();
31218 wxPyEndAllowThreads(__tstate);
31219 if (PyErr_Occurred()) SWIG_fail;
31220 }
31221 resultobj = SWIG_From_int(static_cast< int >(result));
31222 return resultobj;
31223 fail:
31224 return NULL;
31225 }
31226
31227
31228 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj = 0;
31230 int arg1 ;
31231 int result;
31232 int val1 ;
31233 int ecode1 = 0 ;
31234 PyObject * obj0 = 0 ;
31235 char * kwnames[] = {
31236 (char *) "winid", NULL
31237 };
31238
31239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31240 ecode1 = SWIG_AsVal_int(obj0, &val1);
31241 if (!SWIG_IsOK(ecode1)) {
31242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31243 }
31244 arg1 = static_cast< int >(val1);
31245 {
31246 PyThreadState* __tstate = wxPyBeginAllowThreads();
31247 result = (int)wxWindow::NextControlId(arg1);
31248 wxPyEndAllowThreads(__tstate);
31249 if (PyErr_Occurred()) SWIG_fail;
31250 }
31251 resultobj = SWIG_From_int(static_cast< int >(result));
31252 return resultobj;
31253 fail:
31254 return NULL;
31255 }
31256
31257
31258 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31259 PyObject *resultobj = 0;
31260 int arg1 ;
31261 int result;
31262 int val1 ;
31263 int ecode1 = 0 ;
31264 PyObject * obj0 = 0 ;
31265 char * kwnames[] = {
31266 (char *) "winid", NULL
31267 };
31268
31269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31270 ecode1 = SWIG_AsVal_int(obj0, &val1);
31271 if (!SWIG_IsOK(ecode1)) {
31272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31273 }
31274 arg1 = static_cast< int >(val1);
31275 {
31276 PyThreadState* __tstate = wxPyBeginAllowThreads();
31277 result = (int)wxWindow::PrevControlId(arg1);
31278 wxPyEndAllowThreads(__tstate);
31279 if (PyErr_Occurred()) SWIG_fail;
31280 }
31281 resultobj = SWIG_From_int(static_cast< int >(result));
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31289 PyObject *resultobj = 0;
31290 wxWindow *arg1 = (wxWindow *) 0 ;
31291 wxLayoutDirection result;
31292 void *argp1 = 0 ;
31293 int res1 = 0 ;
31294 PyObject *swig_obj[1] ;
31295
31296 if (!args) SWIG_fail;
31297 swig_obj[0] = args;
31298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31299 if (!SWIG_IsOK(res1)) {
31300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31301 }
31302 arg1 = reinterpret_cast< wxWindow * >(argp1);
31303 {
31304 PyThreadState* __tstate = wxPyBeginAllowThreads();
31305 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31306 wxPyEndAllowThreads(__tstate);
31307 if (PyErr_Occurred()) SWIG_fail;
31308 }
31309 resultobj = SWIG_From_int(static_cast< int >(result));
31310 return resultobj;
31311 fail:
31312 return NULL;
31313 }
31314
31315
31316 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31317 PyObject *resultobj = 0;
31318 wxWindow *arg1 = (wxWindow *) 0 ;
31319 wxLayoutDirection arg2 ;
31320 void *argp1 = 0 ;
31321 int res1 = 0 ;
31322 int val2 ;
31323 int ecode2 = 0 ;
31324 PyObject * obj0 = 0 ;
31325 PyObject * obj1 = 0 ;
31326 char * kwnames[] = {
31327 (char *) "self",(char *) "dir", NULL
31328 };
31329
31330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31332 if (!SWIG_IsOK(res1)) {
31333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31334 }
31335 arg1 = reinterpret_cast< wxWindow * >(argp1);
31336 ecode2 = SWIG_AsVal_int(obj1, &val2);
31337 if (!SWIG_IsOK(ecode2)) {
31338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31339 }
31340 arg2 = static_cast< wxLayoutDirection >(val2);
31341 {
31342 PyThreadState* __tstate = wxPyBeginAllowThreads();
31343 (arg1)->SetLayoutDirection(arg2);
31344 wxPyEndAllowThreads(__tstate);
31345 if (PyErr_Occurred()) SWIG_fail;
31346 }
31347 resultobj = SWIG_Py_Void();
31348 return resultobj;
31349 fail:
31350 return NULL;
31351 }
31352
31353
31354 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31355 PyObject *resultobj = 0;
31356 wxWindow *arg1 = (wxWindow *) 0 ;
31357 int arg2 ;
31358 int arg3 ;
31359 int arg4 ;
31360 int result;
31361 void *argp1 = 0 ;
31362 int res1 = 0 ;
31363 int val2 ;
31364 int ecode2 = 0 ;
31365 int val3 ;
31366 int ecode3 = 0 ;
31367 int val4 ;
31368 int ecode4 = 0 ;
31369 PyObject * obj0 = 0 ;
31370 PyObject * obj1 = 0 ;
31371 PyObject * obj2 = 0 ;
31372 PyObject * obj3 = 0 ;
31373 char * kwnames[] = {
31374 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31375 };
31376
31377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31379 if (!SWIG_IsOK(res1)) {
31380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31381 }
31382 arg1 = reinterpret_cast< wxWindow * >(argp1);
31383 ecode2 = SWIG_AsVal_int(obj1, &val2);
31384 if (!SWIG_IsOK(ecode2)) {
31385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31386 }
31387 arg2 = static_cast< int >(val2);
31388 ecode3 = SWIG_AsVal_int(obj2, &val3);
31389 if (!SWIG_IsOK(ecode3)) {
31390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31391 }
31392 arg3 = static_cast< int >(val3);
31393 ecode4 = SWIG_AsVal_int(obj3, &val4);
31394 if (!SWIG_IsOK(ecode4)) {
31395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31396 }
31397 arg4 = static_cast< int >(val4);
31398 {
31399 PyThreadState* __tstate = wxPyBeginAllowThreads();
31400 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31401 wxPyEndAllowThreads(__tstate);
31402 if (PyErr_Occurred()) SWIG_fail;
31403 }
31404 resultobj = SWIG_From_int(static_cast< int >(result));
31405 return resultobj;
31406 fail:
31407 return NULL;
31408 }
31409
31410
31411 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31412 PyObject *resultobj = 0;
31413 wxWindow *arg1 = (wxWindow *) 0 ;
31414 wxSize *arg2 = 0 ;
31415 void *argp1 = 0 ;
31416 int res1 = 0 ;
31417 wxSize temp2 ;
31418 PyObject * obj0 = 0 ;
31419 PyObject * obj1 = 0 ;
31420 char * kwnames[] = {
31421 (char *) "self",(char *) "size", NULL
31422 };
31423
31424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31426 if (!SWIG_IsOK(res1)) {
31427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31428 }
31429 arg1 = reinterpret_cast< wxWindow * >(argp1);
31430 {
31431 arg2 = &temp2;
31432 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31433 }
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 (arg1)->SetSize((wxSize const &)*arg2);
31437 wxPyEndAllowThreads(__tstate);
31438 if (PyErr_Occurred()) SWIG_fail;
31439 }
31440 resultobj = SWIG_Py_Void();
31441 return resultobj;
31442 fail:
31443 return NULL;
31444 }
31445
31446
31447 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31448 PyObject *resultobj = 0;
31449 wxWindow *arg1 = (wxWindow *) 0 ;
31450 int arg2 ;
31451 int arg3 ;
31452 int arg4 ;
31453 int arg5 ;
31454 int arg6 = (int) wxSIZE_AUTO ;
31455 void *argp1 = 0 ;
31456 int res1 = 0 ;
31457 int val2 ;
31458 int ecode2 = 0 ;
31459 int val3 ;
31460 int ecode3 = 0 ;
31461 int val4 ;
31462 int ecode4 = 0 ;
31463 int val5 ;
31464 int ecode5 = 0 ;
31465 int val6 ;
31466 int ecode6 = 0 ;
31467 PyObject * obj0 = 0 ;
31468 PyObject * obj1 = 0 ;
31469 PyObject * obj2 = 0 ;
31470 PyObject * obj3 = 0 ;
31471 PyObject * obj4 = 0 ;
31472 PyObject * obj5 = 0 ;
31473 char * kwnames[] = {
31474 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31475 };
31476
31477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31479 if (!SWIG_IsOK(res1)) {
31480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31481 }
31482 arg1 = reinterpret_cast< wxWindow * >(argp1);
31483 ecode2 = SWIG_AsVal_int(obj1, &val2);
31484 if (!SWIG_IsOK(ecode2)) {
31485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31486 }
31487 arg2 = static_cast< int >(val2);
31488 ecode3 = SWIG_AsVal_int(obj2, &val3);
31489 if (!SWIG_IsOK(ecode3)) {
31490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31491 }
31492 arg3 = static_cast< int >(val3);
31493 ecode4 = SWIG_AsVal_int(obj3, &val4);
31494 if (!SWIG_IsOK(ecode4)) {
31495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31496 }
31497 arg4 = static_cast< int >(val4);
31498 ecode5 = SWIG_AsVal_int(obj4, &val5);
31499 if (!SWIG_IsOK(ecode5)) {
31500 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31501 }
31502 arg5 = static_cast< int >(val5);
31503 if (obj5) {
31504 ecode6 = SWIG_AsVal_int(obj5, &val6);
31505 if (!SWIG_IsOK(ecode6)) {
31506 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31507 }
31508 arg6 = static_cast< int >(val6);
31509 }
31510 {
31511 PyThreadState* __tstate = wxPyBeginAllowThreads();
31512 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31513 wxPyEndAllowThreads(__tstate);
31514 if (PyErr_Occurred()) SWIG_fail;
31515 }
31516 resultobj = SWIG_Py_Void();
31517 return resultobj;
31518 fail:
31519 return NULL;
31520 }
31521
31522
31523 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31524 PyObject *resultobj = 0;
31525 wxWindow *arg1 = (wxWindow *) 0 ;
31526 wxRect *arg2 = 0 ;
31527 int arg3 = (int) wxSIZE_AUTO ;
31528 void *argp1 = 0 ;
31529 int res1 = 0 ;
31530 wxRect temp2 ;
31531 int val3 ;
31532 int ecode3 = 0 ;
31533 PyObject * obj0 = 0 ;
31534 PyObject * obj1 = 0 ;
31535 PyObject * obj2 = 0 ;
31536 char * kwnames[] = {
31537 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31538 };
31539
31540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31542 if (!SWIG_IsOK(res1)) {
31543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31544 }
31545 arg1 = reinterpret_cast< wxWindow * >(argp1);
31546 {
31547 arg2 = &temp2;
31548 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31549 }
31550 if (obj2) {
31551 ecode3 = SWIG_AsVal_int(obj2, &val3);
31552 if (!SWIG_IsOK(ecode3)) {
31553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31554 }
31555 arg3 = static_cast< int >(val3);
31556 }
31557 {
31558 PyThreadState* __tstate = wxPyBeginAllowThreads();
31559 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31560 wxPyEndAllowThreads(__tstate);
31561 if (PyErr_Occurred()) SWIG_fail;
31562 }
31563 resultobj = SWIG_Py_Void();
31564 return resultobj;
31565 fail:
31566 return NULL;
31567 }
31568
31569
31570 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31571 PyObject *resultobj = 0;
31572 wxWindow *arg1 = (wxWindow *) 0 ;
31573 int arg2 ;
31574 int arg3 ;
31575 void *argp1 = 0 ;
31576 int res1 = 0 ;
31577 int val2 ;
31578 int ecode2 = 0 ;
31579 int val3 ;
31580 int ecode3 = 0 ;
31581 PyObject * obj0 = 0 ;
31582 PyObject * obj1 = 0 ;
31583 PyObject * obj2 = 0 ;
31584 char * kwnames[] = {
31585 (char *) "self",(char *) "width",(char *) "height", NULL
31586 };
31587
31588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31590 if (!SWIG_IsOK(res1)) {
31591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31592 }
31593 arg1 = reinterpret_cast< wxWindow * >(argp1);
31594 ecode2 = SWIG_AsVal_int(obj1, &val2);
31595 if (!SWIG_IsOK(ecode2)) {
31596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31597 }
31598 arg2 = static_cast< int >(val2);
31599 ecode3 = SWIG_AsVal_int(obj2, &val3);
31600 if (!SWIG_IsOK(ecode3)) {
31601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31602 }
31603 arg3 = static_cast< int >(val3);
31604 {
31605 PyThreadState* __tstate = wxPyBeginAllowThreads();
31606 (arg1)->SetSize(arg2,arg3);
31607 wxPyEndAllowThreads(__tstate);
31608 if (PyErr_Occurred()) SWIG_fail;
31609 }
31610 resultobj = SWIG_Py_Void();
31611 return resultobj;
31612 fail:
31613 return NULL;
31614 }
31615
31616
31617 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31618 PyObject *resultobj = 0;
31619 wxWindow *arg1 = (wxWindow *) 0 ;
31620 wxPoint *arg2 = 0 ;
31621 int arg3 = (int) wxSIZE_USE_EXISTING ;
31622 void *argp1 = 0 ;
31623 int res1 = 0 ;
31624 wxPoint temp2 ;
31625 int val3 ;
31626 int ecode3 = 0 ;
31627 PyObject * obj0 = 0 ;
31628 PyObject * obj1 = 0 ;
31629 PyObject * obj2 = 0 ;
31630 char * kwnames[] = {
31631 (char *) "self",(char *) "pt",(char *) "flags", NULL
31632 };
31633
31634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31636 if (!SWIG_IsOK(res1)) {
31637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31638 }
31639 arg1 = reinterpret_cast< wxWindow * >(argp1);
31640 {
31641 arg2 = &temp2;
31642 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31643 }
31644 if (obj2) {
31645 ecode3 = SWIG_AsVal_int(obj2, &val3);
31646 if (!SWIG_IsOK(ecode3)) {
31647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31648 }
31649 arg3 = static_cast< int >(val3);
31650 }
31651 {
31652 PyThreadState* __tstate = wxPyBeginAllowThreads();
31653 (arg1)->Move((wxPoint const &)*arg2,arg3);
31654 wxPyEndAllowThreads(__tstate);
31655 if (PyErr_Occurred()) SWIG_fail;
31656 }
31657 resultobj = SWIG_Py_Void();
31658 return resultobj;
31659 fail:
31660 return NULL;
31661 }
31662
31663
31664 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31665 PyObject *resultobj = 0;
31666 wxWindow *arg1 = (wxWindow *) 0 ;
31667 int arg2 ;
31668 int arg3 ;
31669 int arg4 = (int) wxSIZE_USE_EXISTING ;
31670 void *argp1 = 0 ;
31671 int res1 = 0 ;
31672 int val2 ;
31673 int ecode2 = 0 ;
31674 int val3 ;
31675 int ecode3 = 0 ;
31676 int val4 ;
31677 int ecode4 = 0 ;
31678 PyObject * obj0 = 0 ;
31679 PyObject * obj1 = 0 ;
31680 PyObject * obj2 = 0 ;
31681 PyObject * obj3 = 0 ;
31682 char * kwnames[] = {
31683 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31684 };
31685
31686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31688 if (!SWIG_IsOK(res1)) {
31689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31690 }
31691 arg1 = reinterpret_cast< wxWindow * >(argp1);
31692 ecode2 = SWIG_AsVal_int(obj1, &val2);
31693 if (!SWIG_IsOK(ecode2)) {
31694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31695 }
31696 arg2 = static_cast< int >(val2);
31697 ecode3 = SWIG_AsVal_int(obj2, &val3);
31698 if (!SWIG_IsOK(ecode3)) {
31699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31700 }
31701 arg3 = static_cast< int >(val3);
31702 if (obj3) {
31703 ecode4 = SWIG_AsVal_int(obj3, &val4);
31704 if (!SWIG_IsOK(ecode4)) {
31705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31706 }
31707 arg4 = static_cast< int >(val4);
31708 }
31709 {
31710 PyThreadState* __tstate = wxPyBeginAllowThreads();
31711 (arg1)->Move(arg2,arg3,arg4);
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 resultobj = SWIG_Py_Void();
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31723 PyObject *resultobj = 0;
31724 wxWindow *arg1 = (wxWindow *) 0 ;
31725 wxSize const &arg2_defvalue = wxDefaultSize ;
31726 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31727 void *argp1 = 0 ;
31728 int res1 = 0 ;
31729 wxSize temp2 ;
31730 PyObject * obj0 = 0 ;
31731 PyObject * obj1 = 0 ;
31732 char * kwnames[] = {
31733 (char *) "self",(char *) "size", NULL
31734 };
31735
31736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31738 if (!SWIG_IsOK(res1)) {
31739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31740 }
31741 arg1 = reinterpret_cast< wxWindow * >(argp1);
31742 if (obj1) {
31743 {
31744 arg2 = &temp2;
31745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31746 }
31747 }
31748 {
31749 PyThreadState* __tstate = wxPyBeginAllowThreads();
31750 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 resultobj = SWIG_Py_Void();
31755 return resultobj;
31756 fail:
31757 return NULL;
31758 }
31759
31760
31761 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31762 PyObject *resultobj = 0;
31763 wxWindow *arg1 = (wxWindow *) 0 ;
31764 void *argp1 = 0 ;
31765 int res1 = 0 ;
31766 PyObject *swig_obj[1] ;
31767
31768 if (!args) SWIG_fail;
31769 swig_obj[0] = args;
31770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31771 if (!SWIG_IsOK(res1)) {
31772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31773 }
31774 arg1 = reinterpret_cast< wxWindow * >(argp1);
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 (arg1)->Raise();
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_Py_Void();
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31789 PyObject *resultobj = 0;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 PyObject *swig_obj[1] ;
31794
31795 if (!args) SWIG_fail;
31796 swig_obj[0] = args;
31797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31798 if (!SWIG_IsOK(res1)) {
31799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31800 }
31801 arg1 = reinterpret_cast< wxWindow * >(argp1);
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 (arg1)->Lower();
31805 wxPyEndAllowThreads(__tstate);
31806 if (PyErr_Occurred()) SWIG_fail;
31807 }
31808 resultobj = SWIG_Py_Void();
31809 return resultobj;
31810 fail:
31811 return NULL;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31816 PyObject *resultobj = 0;
31817 wxWindow *arg1 = (wxWindow *) 0 ;
31818 wxSize *arg2 = 0 ;
31819 void *argp1 = 0 ;
31820 int res1 = 0 ;
31821 wxSize temp2 ;
31822 PyObject * obj0 = 0 ;
31823 PyObject * obj1 = 0 ;
31824 char * kwnames[] = {
31825 (char *) "self",(char *) "size", NULL
31826 };
31827
31828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31830 if (!SWIG_IsOK(res1)) {
31831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31832 }
31833 arg1 = reinterpret_cast< wxWindow * >(argp1);
31834 {
31835 arg2 = &temp2;
31836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31837 }
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 (arg1)->SetClientSize((wxSize const &)*arg2);
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 resultobj = SWIG_Py_Void();
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31852 PyObject *resultobj = 0;
31853 wxWindow *arg1 = (wxWindow *) 0 ;
31854 int arg2 ;
31855 int arg3 ;
31856 void *argp1 = 0 ;
31857 int res1 = 0 ;
31858 int val2 ;
31859 int ecode2 = 0 ;
31860 int val3 ;
31861 int ecode3 = 0 ;
31862 PyObject * obj0 = 0 ;
31863 PyObject * obj1 = 0 ;
31864 PyObject * obj2 = 0 ;
31865 char * kwnames[] = {
31866 (char *) "self",(char *) "width",(char *) "height", NULL
31867 };
31868
31869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31871 if (!SWIG_IsOK(res1)) {
31872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31873 }
31874 arg1 = reinterpret_cast< wxWindow * >(argp1);
31875 ecode2 = SWIG_AsVal_int(obj1, &val2);
31876 if (!SWIG_IsOK(ecode2)) {
31877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31878 }
31879 arg2 = static_cast< int >(val2);
31880 ecode3 = SWIG_AsVal_int(obj2, &val3);
31881 if (!SWIG_IsOK(ecode3)) {
31882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31883 }
31884 arg3 = static_cast< int >(val3);
31885 {
31886 PyThreadState* __tstate = wxPyBeginAllowThreads();
31887 (arg1)->SetClientSize(arg2,arg3);
31888 wxPyEndAllowThreads(__tstate);
31889 if (PyErr_Occurred()) SWIG_fail;
31890 }
31891 resultobj = SWIG_Py_Void();
31892 return resultobj;
31893 fail:
31894 return NULL;
31895 }
31896
31897
31898 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31899 PyObject *resultobj = 0;
31900 wxWindow *arg1 = (wxWindow *) 0 ;
31901 wxRect *arg2 = 0 ;
31902 void *argp1 = 0 ;
31903 int res1 = 0 ;
31904 wxRect temp2 ;
31905 PyObject * obj0 = 0 ;
31906 PyObject * obj1 = 0 ;
31907 char * kwnames[] = {
31908 (char *) "self",(char *) "rect", NULL
31909 };
31910
31911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31913 if (!SWIG_IsOK(res1)) {
31914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31915 }
31916 arg1 = reinterpret_cast< wxWindow * >(argp1);
31917 {
31918 arg2 = &temp2;
31919 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31920 }
31921 {
31922 PyThreadState* __tstate = wxPyBeginAllowThreads();
31923 (arg1)->SetClientSize((wxRect const &)*arg2);
31924 wxPyEndAllowThreads(__tstate);
31925 if (PyErr_Occurred()) SWIG_fail;
31926 }
31927 resultobj = SWIG_Py_Void();
31928 return resultobj;
31929 fail:
31930 return NULL;
31931 }
31932
31933
31934 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31935 PyObject *resultobj = 0;
31936 wxWindow *arg1 = (wxWindow *) 0 ;
31937 wxPoint result;
31938 void *argp1 = 0 ;
31939 int res1 = 0 ;
31940 PyObject *swig_obj[1] ;
31941
31942 if (!args) SWIG_fail;
31943 swig_obj[0] = args;
31944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31945 if (!SWIG_IsOK(res1)) {
31946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31947 }
31948 arg1 = reinterpret_cast< wxWindow * >(argp1);
31949 {
31950 PyThreadState* __tstate = wxPyBeginAllowThreads();
31951 result = ((wxWindow const *)arg1)->GetPosition();
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31956 return resultobj;
31957 fail:
31958 return NULL;
31959 }
31960
31961
31962 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31963 PyObject *resultobj = 0;
31964 wxWindow *arg1 = (wxWindow *) 0 ;
31965 int *arg2 = (int *) 0 ;
31966 int *arg3 = (int *) 0 ;
31967 void *argp1 = 0 ;
31968 int res1 = 0 ;
31969 int temp2 ;
31970 int res2 = SWIG_TMPOBJ ;
31971 int temp3 ;
31972 int res3 = SWIG_TMPOBJ ;
31973 PyObject *swig_obj[1] ;
31974
31975 arg2 = &temp2;
31976 arg3 = &temp3;
31977 if (!args) SWIG_fail;
31978 swig_obj[0] = args;
31979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31980 if (!SWIG_IsOK(res1)) {
31981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31982 }
31983 arg1 = reinterpret_cast< wxWindow * >(argp1);
31984 {
31985 PyThreadState* __tstate = wxPyBeginAllowThreads();
31986 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31987 wxPyEndAllowThreads(__tstate);
31988 if (PyErr_Occurred()) SWIG_fail;
31989 }
31990 resultobj = SWIG_Py_Void();
31991 if (SWIG_IsTmpObj(res2)) {
31992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31993 } else {
31994 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31996 }
31997 if (SWIG_IsTmpObj(res3)) {
31998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31999 } else {
32000 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32002 }
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32010 PyObject *resultobj = 0;
32011 wxWindow *arg1 = (wxWindow *) 0 ;
32012 wxPoint result;
32013 void *argp1 = 0 ;
32014 int res1 = 0 ;
32015 PyObject *swig_obj[1] ;
32016
32017 if (!args) SWIG_fail;
32018 swig_obj[0] = args;
32019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32020 if (!SWIG_IsOK(res1)) {
32021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
32022 }
32023 arg1 = reinterpret_cast< wxWindow * >(argp1);
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 result = ((wxWindow const *)arg1)->GetScreenPosition();
32027 wxPyEndAllowThreads(__tstate);
32028 if (PyErr_Occurred()) SWIG_fail;
32029 }
32030 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32038 PyObject *resultobj = 0;
32039 wxWindow *arg1 = (wxWindow *) 0 ;
32040 int *arg2 = (int *) 0 ;
32041 int *arg3 = (int *) 0 ;
32042 void *argp1 = 0 ;
32043 int res1 = 0 ;
32044 int temp2 ;
32045 int res2 = SWIG_TMPOBJ ;
32046 int temp3 ;
32047 int res3 = SWIG_TMPOBJ ;
32048 PyObject *swig_obj[1] ;
32049
32050 arg2 = &temp2;
32051 arg3 = &temp3;
32052 if (!args) SWIG_fail;
32053 swig_obj[0] = args;
32054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32055 if (!SWIG_IsOK(res1)) {
32056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32057 }
32058 arg1 = reinterpret_cast< wxWindow * >(argp1);
32059 {
32060 PyThreadState* __tstate = wxPyBeginAllowThreads();
32061 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 resultobj = SWIG_Py_Void();
32066 if (SWIG_IsTmpObj(res2)) {
32067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32068 } else {
32069 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32071 }
32072 if (SWIG_IsTmpObj(res3)) {
32073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32074 } else {
32075 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32077 }
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32085 PyObject *resultobj = 0;
32086 wxWindow *arg1 = (wxWindow *) 0 ;
32087 wxRect result;
32088 void *argp1 = 0 ;
32089 int res1 = 0 ;
32090 PyObject *swig_obj[1] ;
32091
32092 if (!args) SWIG_fail;
32093 swig_obj[0] = args;
32094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32095 if (!SWIG_IsOK(res1)) {
32096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32097 }
32098 arg1 = reinterpret_cast< wxWindow * >(argp1);
32099 {
32100 PyThreadState* __tstate = wxPyBeginAllowThreads();
32101 result = ((wxWindow const *)arg1)->GetScreenRect();
32102 wxPyEndAllowThreads(__tstate);
32103 if (PyErr_Occurred()) SWIG_fail;
32104 }
32105 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32106 return resultobj;
32107 fail:
32108 return NULL;
32109 }
32110
32111
32112 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32113 PyObject *resultobj = 0;
32114 wxWindow *arg1 = (wxWindow *) 0 ;
32115 wxSize result;
32116 void *argp1 = 0 ;
32117 int res1 = 0 ;
32118 PyObject *swig_obj[1] ;
32119
32120 if (!args) SWIG_fail;
32121 swig_obj[0] = args;
32122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32123 if (!SWIG_IsOK(res1)) {
32124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32125 }
32126 arg1 = reinterpret_cast< wxWindow * >(argp1);
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 result = ((wxWindow const *)arg1)->GetSize();
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32134 return resultobj;
32135 fail:
32136 return NULL;
32137 }
32138
32139
32140 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32141 PyObject *resultobj = 0;
32142 wxWindow *arg1 = (wxWindow *) 0 ;
32143 int *arg2 = (int *) 0 ;
32144 int *arg3 = (int *) 0 ;
32145 void *argp1 = 0 ;
32146 int res1 = 0 ;
32147 int temp2 ;
32148 int res2 = SWIG_TMPOBJ ;
32149 int temp3 ;
32150 int res3 = SWIG_TMPOBJ ;
32151 PyObject *swig_obj[1] ;
32152
32153 arg2 = &temp2;
32154 arg3 = &temp3;
32155 if (!args) SWIG_fail;
32156 swig_obj[0] = args;
32157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32158 if (!SWIG_IsOK(res1)) {
32159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32160 }
32161 arg1 = reinterpret_cast< wxWindow * >(argp1);
32162 {
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32165 wxPyEndAllowThreads(__tstate);
32166 if (PyErr_Occurred()) SWIG_fail;
32167 }
32168 resultobj = SWIG_Py_Void();
32169 if (SWIG_IsTmpObj(res2)) {
32170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32171 } else {
32172 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32174 }
32175 if (SWIG_IsTmpObj(res3)) {
32176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32177 } else {
32178 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32180 }
32181 return resultobj;
32182 fail:
32183 return NULL;
32184 }
32185
32186
32187 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32188 PyObject *resultobj = 0;
32189 wxWindow *arg1 = (wxWindow *) 0 ;
32190 wxRect result;
32191 void *argp1 = 0 ;
32192 int res1 = 0 ;
32193 PyObject *swig_obj[1] ;
32194
32195 if (!args) SWIG_fail;
32196 swig_obj[0] = args;
32197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32198 if (!SWIG_IsOK(res1)) {
32199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32200 }
32201 arg1 = reinterpret_cast< wxWindow * >(argp1);
32202 {
32203 PyThreadState* __tstate = wxPyBeginAllowThreads();
32204 result = ((wxWindow const *)arg1)->GetRect();
32205 wxPyEndAllowThreads(__tstate);
32206 if (PyErr_Occurred()) SWIG_fail;
32207 }
32208 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32216 PyObject *resultobj = 0;
32217 wxWindow *arg1 = (wxWindow *) 0 ;
32218 wxSize result;
32219 void *argp1 = 0 ;
32220 int res1 = 0 ;
32221 PyObject *swig_obj[1] ;
32222
32223 if (!args) SWIG_fail;
32224 swig_obj[0] = args;
32225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32226 if (!SWIG_IsOK(res1)) {
32227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32228 }
32229 arg1 = reinterpret_cast< wxWindow * >(argp1);
32230 {
32231 PyThreadState* __tstate = wxPyBeginAllowThreads();
32232 result = ((wxWindow const *)arg1)->GetClientSize();
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32237 return resultobj;
32238 fail:
32239 return NULL;
32240 }
32241
32242
32243 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32244 PyObject *resultobj = 0;
32245 wxWindow *arg1 = (wxWindow *) 0 ;
32246 int *arg2 = (int *) 0 ;
32247 int *arg3 = (int *) 0 ;
32248 void *argp1 = 0 ;
32249 int res1 = 0 ;
32250 int temp2 ;
32251 int res2 = SWIG_TMPOBJ ;
32252 int temp3 ;
32253 int res3 = SWIG_TMPOBJ ;
32254 PyObject *swig_obj[1] ;
32255
32256 arg2 = &temp2;
32257 arg3 = &temp3;
32258 if (!args) SWIG_fail;
32259 swig_obj[0] = args;
32260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32261 if (!SWIG_IsOK(res1)) {
32262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32263 }
32264 arg1 = reinterpret_cast< wxWindow * >(argp1);
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32268 wxPyEndAllowThreads(__tstate);
32269 if (PyErr_Occurred()) SWIG_fail;
32270 }
32271 resultobj = SWIG_Py_Void();
32272 if (SWIG_IsTmpObj(res2)) {
32273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32274 } else {
32275 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32277 }
32278 if (SWIG_IsTmpObj(res3)) {
32279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32280 } else {
32281 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32283 }
32284 return resultobj;
32285 fail:
32286 return NULL;
32287 }
32288
32289
32290 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32291 PyObject *resultobj = 0;
32292 wxWindow *arg1 = (wxWindow *) 0 ;
32293 wxPoint 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_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32303 }
32304 arg1 = reinterpret_cast< wxWindow * >(argp1);
32305 {
32306 PyThreadState* __tstate = wxPyBeginAllowThreads();
32307 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32308 wxPyEndAllowThreads(__tstate);
32309 if (PyErr_Occurred()) SWIG_fail;
32310 }
32311 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32312 return resultobj;
32313 fail:
32314 return NULL;
32315 }
32316
32317
32318 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32319 PyObject *resultobj = 0;
32320 wxWindow *arg1 = (wxWindow *) 0 ;
32321 wxRect result;
32322 void *argp1 = 0 ;
32323 int res1 = 0 ;
32324 PyObject *swig_obj[1] ;
32325
32326 if (!args) SWIG_fail;
32327 swig_obj[0] = args;
32328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32329 if (!SWIG_IsOK(res1)) {
32330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32331 }
32332 arg1 = reinterpret_cast< wxWindow * >(argp1);
32333 {
32334 PyThreadState* __tstate = wxPyBeginAllowThreads();
32335 result = ((wxWindow const *)arg1)->GetClientRect();
32336 wxPyEndAllowThreads(__tstate);
32337 if (PyErr_Occurred()) SWIG_fail;
32338 }
32339 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32340 return resultobj;
32341 fail:
32342 return NULL;
32343 }
32344
32345
32346 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32347 PyObject *resultobj = 0;
32348 wxWindow *arg1 = (wxWindow *) 0 ;
32349 wxSize result;
32350 void *argp1 = 0 ;
32351 int res1 = 0 ;
32352 PyObject *swig_obj[1] ;
32353
32354 if (!args) SWIG_fail;
32355 swig_obj[0] = args;
32356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32357 if (!SWIG_IsOK(res1)) {
32358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32359 }
32360 arg1 = reinterpret_cast< wxWindow * >(argp1);
32361 {
32362 PyThreadState* __tstate = wxPyBeginAllowThreads();
32363 result = ((wxWindow const *)arg1)->GetBestSize();
32364 wxPyEndAllowThreads(__tstate);
32365 if (PyErr_Occurred()) SWIG_fail;
32366 }
32367 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32368 return resultobj;
32369 fail:
32370 return NULL;
32371 }
32372
32373
32374 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32375 PyObject *resultobj = 0;
32376 wxWindow *arg1 = (wxWindow *) 0 ;
32377 int *arg2 = (int *) 0 ;
32378 int *arg3 = (int *) 0 ;
32379 void *argp1 = 0 ;
32380 int res1 = 0 ;
32381 int temp2 ;
32382 int res2 = SWIG_TMPOBJ ;
32383 int temp3 ;
32384 int res3 = SWIG_TMPOBJ ;
32385 PyObject *swig_obj[1] ;
32386
32387 arg2 = &temp2;
32388 arg3 = &temp3;
32389 if (!args) SWIG_fail;
32390 swig_obj[0] = args;
32391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32392 if (!SWIG_IsOK(res1)) {
32393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32394 }
32395 arg1 = reinterpret_cast< wxWindow * >(argp1);
32396 {
32397 PyThreadState* __tstate = wxPyBeginAllowThreads();
32398 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32399 wxPyEndAllowThreads(__tstate);
32400 if (PyErr_Occurred()) SWIG_fail;
32401 }
32402 resultobj = SWIG_Py_Void();
32403 if (SWIG_IsTmpObj(res2)) {
32404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32405 } else {
32406 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32407 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32408 }
32409 if (SWIG_IsTmpObj(res3)) {
32410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32411 } else {
32412 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32414 }
32415 return resultobj;
32416 fail:
32417 return NULL;
32418 }
32419
32420
32421 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32422 PyObject *resultobj = 0;
32423 wxWindow *arg1 = (wxWindow *) 0 ;
32424 void *argp1 = 0 ;
32425 int res1 = 0 ;
32426 PyObject *swig_obj[1] ;
32427
32428 if (!args) SWIG_fail;
32429 swig_obj[0] = args;
32430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32431 if (!SWIG_IsOK(res1)) {
32432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32433 }
32434 arg1 = reinterpret_cast< wxWindow * >(argp1);
32435 {
32436 PyThreadState* __tstate = wxPyBeginAllowThreads();
32437 (arg1)->InvalidateBestSize();
32438 wxPyEndAllowThreads(__tstate);
32439 if (PyErr_Occurred()) SWIG_fail;
32440 }
32441 resultobj = SWIG_Py_Void();
32442 return resultobj;
32443 fail:
32444 return NULL;
32445 }
32446
32447
32448 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32449 PyObject *resultobj = 0;
32450 wxWindow *arg1 = (wxWindow *) 0 ;
32451 wxSize *arg2 = 0 ;
32452 void *argp1 = 0 ;
32453 int res1 = 0 ;
32454 wxSize temp2 ;
32455 PyObject * obj0 = 0 ;
32456 PyObject * obj1 = 0 ;
32457 char * kwnames[] = {
32458 (char *) "self",(char *) "size", NULL
32459 };
32460
32461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32463 if (!SWIG_IsOK(res1)) {
32464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32465 }
32466 arg1 = reinterpret_cast< wxWindow * >(argp1);
32467 {
32468 arg2 = &temp2;
32469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32470 }
32471 {
32472 PyThreadState* __tstate = wxPyBeginAllowThreads();
32473 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32474 wxPyEndAllowThreads(__tstate);
32475 if (PyErr_Occurred()) SWIG_fail;
32476 }
32477 resultobj = SWIG_Py_Void();
32478 return resultobj;
32479 fail:
32480 return NULL;
32481 }
32482
32483
32484 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32485 PyObject *resultobj = 0;
32486 wxWindow *arg1 = (wxWindow *) 0 ;
32487 wxSize result;
32488 void *argp1 = 0 ;
32489 int res1 = 0 ;
32490 PyObject *swig_obj[1] ;
32491
32492 if (!args) SWIG_fail;
32493 swig_obj[0] = args;
32494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32495 if (!SWIG_IsOK(res1)) {
32496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32497 }
32498 arg1 = reinterpret_cast< wxWindow * >(argp1);
32499 {
32500 PyThreadState* __tstate = wxPyBeginAllowThreads();
32501 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32502 wxPyEndAllowThreads(__tstate);
32503 if (PyErr_Occurred()) SWIG_fail;
32504 }
32505 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32506 return resultobj;
32507 fail:
32508 return NULL;
32509 }
32510
32511
32512 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32513 PyObject *resultobj = 0;
32514 wxWindow *arg1 = (wxWindow *) 0 ;
32515 wxSize result;
32516 void *argp1 = 0 ;
32517 int res1 = 0 ;
32518 PyObject *swig_obj[1] ;
32519
32520 if (!args) SWIG_fail;
32521 swig_obj[0] = args;
32522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32523 if (!SWIG_IsOK(res1)) {
32524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32525 }
32526 arg1 = reinterpret_cast< wxWindow * >(argp1);
32527 {
32528 PyThreadState* __tstate = wxPyBeginAllowThreads();
32529 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32530 wxPyEndAllowThreads(__tstate);
32531 if (PyErr_Occurred()) SWIG_fail;
32532 }
32533 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32534 return resultobj;
32535 fail:
32536 return NULL;
32537 }
32538
32539
32540 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32541 PyObject *resultobj = 0;
32542 wxWindow *arg1 = (wxWindow *) 0 ;
32543 int arg2 = (int) wxBOTH ;
32544 void *argp1 = 0 ;
32545 int res1 = 0 ;
32546 int val2 ;
32547 int ecode2 = 0 ;
32548 PyObject * obj0 = 0 ;
32549 PyObject * obj1 = 0 ;
32550 char * kwnames[] = {
32551 (char *) "self",(char *) "direction", NULL
32552 };
32553
32554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32556 if (!SWIG_IsOK(res1)) {
32557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32558 }
32559 arg1 = reinterpret_cast< wxWindow * >(argp1);
32560 if (obj1) {
32561 ecode2 = SWIG_AsVal_int(obj1, &val2);
32562 if (!SWIG_IsOK(ecode2)) {
32563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32564 }
32565 arg2 = static_cast< int >(val2);
32566 }
32567 {
32568 PyThreadState* __tstate = wxPyBeginAllowThreads();
32569 (arg1)->Center(arg2);
32570 wxPyEndAllowThreads(__tstate);
32571 if (PyErr_Occurred()) SWIG_fail;
32572 }
32573 resultobj = SWIG_Py_Void();
32574 return resultobj;
32575 fail:
32576 return NULL;
32577 }
32578
32579
32580 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32581 PyObject *resultobj = 0;
32582 wxWindow *arg1 = (wxWindow *) 0 ;
32583 int arg2 = (int) wxBOTH ;
32584 void *argp1 = 0 ;
32585 int res1 = 0 ;
32586 int val2 ;
32587 int ecode2 = 0 ;
32588 PyObject * obj0 = 0 ;
32589 PyObject * obj1 = 0 ;
32590 char * kwnames[] = {
32591 (char *) "self",(char *) "dir", NULL
32592 };
32593
32594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32596 if (!SWIG_IsOK(res1)) {
32597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32598 }
32599 arg1 = reinterpret_cast< wxWindow * >(argp1);
32600 if (obj1) {
32601 ecode2 = SWIG_AsVal_int(obj1, &val2);
32602 if (!SWIG_IsOK(ecode2)) {
32603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32604 }
32605 arg2 = static_cast< int >(val2);
32606 }
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 (arg1)->CenterOnParent(arg2);
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 resultobj = SWIG_Py_Void();
32614 return resultobj;
32615 fail:
32616 return NULL;
32617 }
32618
32619
32620 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32621 PyObject *resultobj = 0;
32622 wxWindow *arg1 = (wxWindow *) 0 ;
32623 void *argp1 = 0 ;
32624 int res1 = 0 ;
32625 PyObject *swig_obj[1] ;
32626
32627 if (!args) SWIG_fail;
32628 swig_obj[0] = args;
32629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32630 if (!SWIG_IsOK(res1)) {
32631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32632 }
32633 arg1 = reinterpret_cast< wxWindow * >(argp1);
32634 {
32635 PyThreadState* __tstate = wxPyBeginAllowThreads();
32636 (arg1)->Fit();
32637 wxPyEndAllowThreads(__tstate);
32638 if (PyErr_Occurred()) SWIG_fail;
32639 }
32640 resultobj = SWIG_Py_Void();
32641 return resultobj;
32642 fail:
32643 return NULL;
32644 }
32645
32646
32647 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32648 PyObject *resultobj = 0;
32649 wxWindow *arg1 = (wxWindow *) 0 ;
32650 void *argp1 = 0 ;
32651 int res1 = 0 ;
32652 PyObject *swig_obj[1] ;
32653
32654 if (!args) SWIG_fail;
32655 swig_obj[0] = args;
32656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32657 if (!SWIG_IsOK(res1)) {
32658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32659 }
32660 arg1 = reinterpret_cast< wxWindow * >(argp1);
32661 {
32662 PyThreadState* __tstate = wxPyBeginAllowThreads();
32663 (arg1)->FitInside();
32664 wxPyEndAllowThreads(__tstate);
32665 if (PyErr_Occurred()) SWIG_fail;
32666 }
32667 resultobj = SWIG_Py_Void();
32668 return resultobj;
32669 fail:
32670 return NULL;
32671 }
32672
32673
32674 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32675 PyObject *resultobj = 0;
32676 wxWindow *arg1 = (wxWindow *) 0 ;
32677 int arg2 ;
32678 int arg3 ;
32679 int arg4 = (int) -1 ;
32680 int arg5 = (int) -1 ;
32681 int arg6 = (int) -1 ;
32682 int arg7 = (int) -1 ;
32683 void *argp1 = 0 ;
32684 int res1 = 0 ;
32685 int val2 ;
32686 int ecode2 = 0 ;
32687 int val3 ;
32688 int ecode3 = 0 ;
32689 int val4 ;
32690 int ecode4 = 0 ;
32691 int val5 ;
32692 int ecode5 = 0 ;
32693 int val6 ;
32694 int ecode6 = 0 ;
32695 int val7 ;
32696 int ecode7 = 0 ;
32697 PyObject * obj0 = 0 ;
32698 PyObject * obj1 = 0 ;
32699 PyObject * obj2 = 0 ;
32700 PyObject * obj3 = 0 ;
32701 PyObject * obj4 = 0 ;
32702 PyObject * obj5 = 0 ;
32703 PyObject * obj6 = 0 ;
32704 char * kwnames[] = {
32705 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32706 };
32707
32708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32710 if (!SWIG_IsOK(res1)) {
32711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32712 }
32713 arg1 = reinterpret_cast< wxWindow * >(argp1);
32714 ecode2 = SWIG_AsVal_int(obj1, &val2);
32715 if (!SWIG_IsOK(ecode2)) {
32716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32717 }
32718 arg2 = static_cast< int >(val2);
32719 ecode3 = SWIG_AsVal_int(obj2, &val3);
32720 if (!SWIG_IsOK(ecode3)) {
32721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32722 }
32723 arg3 = static_cast< int >(val3);
32724 if (obj3) {
32725 ecode4 = SWIG_AsVal_int(obj3, &val4);
32726 if (!SWIG_IsOK(ecode4)) {
32727 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32728 }
32729 arg4 = static_cast< int >(val4);
32730 }
32731 if (obj4) {
32732 ecode5 = SWIG_AsVal_int(obj4, &val5);
32733 if (!SWIG_IsOK(ecode5)) {
32734 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32735 }
32736 arg5 = static_cast< int >(val5);
32737 }
32738 if (obj5) {
32739 ecode6 = SWIG_AsVal_int(obj5, &val6);
32740 if (!SWIG_IsOK(ecode6)) {
32741 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32742 }
32743 arg6 = static_cast< int >(val6);
32744 }
32745 if (obj6) {
32746 ecode7 = SWIG_AsVal_int(obj6, &val7);
32747 if (!SWIG_IsOK(ecode7)) {
32748 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32749 }
32750 arg7 = static_cast< int >(val7);
32751 }
32752 {
32753 PyThreadState* __tstate = wxPyBeginAllowThreads();
32754 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32755 wxPyEndAllowThreads(__tstate);
32756 if (PyErr_Occurred()) SWIG_fail;
32757 }
32758 resultobj = SWIG_Py_Void();
32759 return resultobj;
32760 fail:
32761 return NULL;
32762 }
32763
32764
32765 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32766 PyObject *resultobj = 0;
32767 wxWindow *arg1 = (wxWindow *) 0 ;
32768 wxSize *arg2 = 0 ;
32769 wxSize const &arg3_defvalue = wxDefaultSize ;
32770 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32771 wxSize const &arg4_defvalue = wxDefaultSize ;
32772 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32773 void *argp1 = 0 ;
32774 int res1 = 0 ;
32775 wxSize temp2 ;
32776 wxSize temp3 ;
32777 wxSize temp4 ;
32778 PyObject * obj0 = 0 ;
32779 PyObject * obj1 = 0 ;
32780 PyObject * obj2 = 0 ;
32781 PyObject * obj3 = 0 ;
32782 char * kwnames[] = {
32783 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32784 };
32785
32786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32788 if (!SWIG_IsOK(res1)) {
32789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32790 }
32791 arg1 = reinterpret_cast< wxWindow * >(argp1);
32792 {
32793 arg2 = &temp2;
32794 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32795 }
32796 if (obj2) {
32797 {
32798 arg3 = &temp3;
32799 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32800 }
32801 }
32802 if (obj3) {
32803 {
32804 arg4 = &temp4;
32805 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32806 }
32807 }
32808 {
32809 PyThreadState* __tstate = wxPyBeginAllowThreads();
32810 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32811 wxPyEndAllowThreads(__tstate);
32812 if (PyErr_Occurred()) SWIG_fail;
32813 }
32814 resultobj = SWIG_Py_Void();
32815 return resultobj;
32816 fail:
32817 return NULL;
32818 }
32819
32820
32821 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32822 PyObject *resultobj = 0;
32823 wxWindow *arg1 = (wxWindow *) 0 ;
32824 int arg2 ;
32825 int arg3 ;
32826 int arg4 = (int) -1 ;
32827 int arg5 = (int) -1 ;
32828 void *argp1 = 0 ;
32829 int res1 = 0 ;
32830 int val2 ;
32831 int ecode2 = 0 ;
32832 int val3 ;
32833 int ecode3 = 0 ;
32834 int val4 ;
32835 int ecode4 = 0 ;
32836 int val5 ;
32837 int ecode5 = 0 ;
32838 PyObject * obj0 = 0 ;
32839 PyObject * obj1 = 0 ;
32840 PyObject * obj2 = 0 ;
32841 PyObject * obj3 = 0 ;
32842 PyObject * obj4 = 0 ;
32843 char * kwnames[] = {
32844 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32845 };
32846
32847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32849 if (!SWIG_IsOK(res1)) {
32850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32851 }
32852 arg1 = reinterpret_cast< wxWindow * >(argp1);
32853 ecode2 = SWIG_AsVal_int(obj1, &val2);
32854 if (!SWIG_IsOK(ecode2)) {
32855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32856 }
32857 arg2 = static_cast< int >(val2);
32858 ecode3 = SWIG_AsVal_int(obj2, &val3);
32859 if (!SWIG_IsOK(ecode3)) {
32860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32861 }
32862 arg3 = static_cast< int >(val3);
32863 if (obj3) {
32864 ecode4 = SWIG_AsVal_int(obj3, &val4);
32865 if (!SWIG_IsOK(ecode4)) {
32866 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32867 }
32868 arg4 = static_cast< int >(val4);
32869 }
32870 if (obj4) {
32871 ecode5 = SWIG_AsVal_int(obj4, &val5);
32872 if (!SWIG_IsOK(ecode5)) {
32873 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32874 }
32875 arg5 = static_cast< int >(val5);
32876 }
32877 {
32878 PyThreadState* __tstate = wxPyBeginAllowThreads();
32879 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32880 wxPyEndAllowThreads(__tstate);
32881 if (PyErr_Occurred()) SWIG_fail;
32882 }
32883 resultobj = SWIG_Py_Void();
32884 return resultobj;
32885 fail:
32886 return NULL;
32887 }
32888
32889
32890 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32891 PyObject *resultobj = 0;
32892 wxWindow *arg1 = (wxWindow *) 0 ;
32893 wxSize *arg2 = 0 ;
32894 wxSize const &arg3_defvalue = wxDefaultSize ;
32895 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32896 void *argp1 = 0 ;
32897 int res1 = 0 ;
32898 wxSize temp2 ;
32899 wxSize temp3 ;
32900 PyObject * obj0 = 0 ;
32901 PyObject * obj1 = 0 ;
32902 PyObject * obj2 = 0 ;
32903 char * kwnames[] = {
32904 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32905 };
32906
32907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32909 if (!SWIG_IsOK(res1)) {
32910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32911 }
32912 arg1 = reinterpret_cast< wxWindow * >(argp1);
32913 {
32914 arg2 = &temp2;
32915 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32916 }
32917 if (obj2) {
32918 {
32919 arg3 = &temp3;
32920 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32921 }
32922 }
32923 {
32924 PyThreadState* __tstate = wxPyBeginAllowThreads();
32925 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32926 wxPyEndAllowThreads(__tstate);
32927 if (PyErr_Occurred()) SWIG_fail;
32928 }
32929 resultobj = SWIG_Py_Void();
32930 return resultobj;
32931 fail:
32932 return NULL;
32933 }
32934
32935
32936 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32937 PyObject *resultobj = 0;
32938 wxWindow *arg1 = (wxWindow *) 0 ;
32939 wxSize result;
32940 void *argp1 = 0 ;
32941 int res1 = 0 ;
32942 PyObject *swig_obj[1] ;
32943
32944 if (!args) SWIG_fail;
32945 swig_obj[0] = args;
32946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32947 if (!SWIG_IsOK(res1)) {
32948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32949 }
32950 arg1 = reinterpret_cast< wxWindow * >(argp1);
32951 {
32952 PyThreadState* __tstate = wxPyBeginAllowThreads();
32953 result = ((wxWindow const *)arg1)->GetMaxSize();
32954 wxPyEndAllowThreads(__tstate);
32955 if (PyErr_Occurred()) SWIG_fail;
32956 }
32957 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32958 return resultobj;
32959 fail:
32960 return NULL;
32961 }
32962
32963
32964 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32965 PyObject *resultobj = 0;
32966 wxWindow *arg1 = (wxWindow *) 0 ;
32967 wxSize result;
32968 void *argp1 = 0 ;
32969 int res1 = 0 ;
32970 PyObject *swig_obj[1] ;
32971
32972 if (!args) SWIG_fail;
32973 swig_obj[0] = args;
32974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32975 if (!SWIG_IsOK(res1)) {
32976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32977 }
32978 arg1 = reinterpret_cast< wxWindow * >(argp1);
32979 {
32980 PyThreadState* __tstate = wxPyBeginAllowThreads();
32981 result = ((wxWindow const *)arg1)->GetMinSize();
32982 wxPyEndAllowThreads(__tstate);
32983 if (PyErr_Occurred()) SWIG_fail;
32984 }
32985 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32986 return resultobj;
32987 fail:
32988 return NULL;
32989 }
32990
32991
32992 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32993 PyObject *resultobj = 0;
32994 wxWindow *arg1 = (wxWindow *) 0 ;
32995 wxSize *arg2 = 0 ;
32996 void *argp1 = 0 ;
32997 int res1 = 0 ;
32998 wxSize temp2 ;
32999 PyObject * obj0 = 0 ;
33000 PyObject * obj1 = 0 ;
33001 char * kwnames[] = {
33002 (char *) "self",(char *) "minSize", NULL
33003 };
33004
33005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
33006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33007 if (!SWIG_IsOK(res1)) {
33008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33009 }
33010 arg1 = reinterpret_cast< wxWindow * >(argp1);
33011 {
33012 arg2 = &temp2;
33013 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33014 }
33015 {
33016 PyThreadState* __tstate = wxPyBeginAllowThreads();
33017 (arg1)->SetMinSize((wxSize const &)*arg2);
33018 wxPyEndAllowThreads(__tstate);
33019 if (PyErr_Occurred()) SWIG_fail;
33020 }
33021 resultobj = SWIG_Py_Void();
33022 return resultobj;
33023 fail:
33024 return NULL;
33025 }
33026
33027
33028 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33029 PyObject *resultobj = 0;
33030 wxWindow *arg1 = (wxWindow *) 0 ;
33031 wxSize *arg2 = 0 ;
33032 void *argp1 = 0 ;
33033 int res1 = 0 ;
33034 wxSize temp2 ;
33035 PyObject * obj0 = 0 ;
33036 PyObject * obj1 = 0 ;
33037 char * kwnames[] = {
33038 (char *) "self",(char *) "maxSize", NULL
33039 };
33040
33041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
33042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33043 if (!SWIG_IsOK(res1)) {
33044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33045 }
33046 arg1 = reinterpret_cast< wxWindow * >(argp1);
33047 {
33048 arg2 = &temp2;
33049 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33050 }
33051 {
33052 PyThreadState* __tstate = wxPyBeginAllowThreads();
33053 (arg1)->SetMaxSize((wxSize const &)*arg2);
33054 wxPyEndAllowThreads(__tstate);
33055 if (PyErr_Occurred()) SWIG_fail;
33056 }
33057 resultobj = SWIG_Py_Void();
33058 return resultobj;
33059 fail:
33060 return NULL;
33061 }
33062
33063
33064 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33065 PyObject *resultobj = 0;
33066 wxWindow *arg1 = (wxWindow *) 0 ;
33067 int result;
33068 void *argp1 = 0 ;
33069 int res1 = 0 ;
33070 PyObject *swig_obj[1] ;
33071
33072 if (!args) SWIG_fail;
33073 swig_obj[0] = args;
33074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33075 if (!SWIG_IsOK(res1)) {
33076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33077 }
33078 arg1 = reinterpret_cast< wxWindow * >(argp1);
33079 {
33080 PyThreadState* __tstate = wxPyBeginAllowThreads();
33081 result = (int)((wxWindow const *)arg1)->GetMinWidth();
33082 wxPyEndAllowThreads(__tstate);
33083 if (PyErr_Occurred()) SWIG_fail;
33084 }
33085 resultobj = SWIG_From_int(static_cast< int >(result));
33086 return resultobj;
33087 fail:
33088 return NULL;
33089 }
33090
33091
33092 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33093 PyObject *resultobj = 0;
33094 wxWindow *arg1 = (wxWindow *) 0 ;
33095 int result;
33096 void *argp1 = 0 ;
33097 int res1 = 0 ;
33098 PyObject *swig_obj[1] ;
33099
33100 if (!args) SWIG_fail;
33101 swig_obj[0] = args;
33102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33103 if (!SWIG_IsOK(res1)) {
33104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33105 }
33106 arg1 = reinterpret_cast< wxWindow * >(argp1);
33107 {
33108 PyThreadState* __tstate = wxPyBeginAllowThreads();
33109 result = (int)((wxWindow const *)arg1)->GetMinHeight();
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 resultobj = SWIG_From_int(static_cast< int >(result));
33114 return resultobj;
33115 fail:
33116 return NULL;
33117 }
33118
33119
33120 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33121 PyObject *resultobj = 0;
33122 wxWindow *arg1 = (wxWindow *) 0 ;
33123 int result;
33124 void *argp1 = 0 ;
33125 int res1 = 0 ;
33126 PyObject *swig_obj[1] ;
33127
33128 if (!args) SWIG_fail;
33129 swig_obj[0] = args;
33130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33131 if (!SWIG_IsOK(res1)) {
33132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33133 }
33134 arg1 = reinterpret_cast< wxWindow * >(argp1);
33135 {
33136 PyThreadState* __tstate = wxPyBeginAllowThreads();
33137 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33138 wxPyEndAllowThreads(__tstate);
33139 if (PyErr_Occurred()) SWIG_fail;
33140 }
33141 resultobj = SWIG_From_int(static_cast< int >(result));
33142 return resultobj;
33143 fail:
33144 return NULL;
33145 }
33146
33147
33148 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33149 PyObject *resultobj = 0;
33150 wxWindow *arg1 = (wxWindow *) 0 ;
33151 int result;
33152 void *argp1 = 0 ;
33153 int res1 = 0 ;
33154 PyObject *swig_obj[1] ;
33155
33156 if (!args) SWIG_fail;
33157 swig_obj[0] = args;
33158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33159 if (!SWIG_IsOK(res1)) {
33160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33161 }
33162 arg1 = reinterpret_cast< wxWindow * >(argp1);
33163 {
33164 PyThreadState* __tstate = wxPyBeginAllowThreads();
33165 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33166 wxPyEndAllowThreads(__tstate);
33167 if (PyErr_Occurred()) SWIG_fail;
33168 }
33169 resultobj = SWIG_From_int(static_cast< int >(result));
33170 return resultobj;
33171 fail:
33172 return NULL;
33173 }
33174
33175
33176 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33177 PyObject *resultobj = 0;
33178 wxWindow *arg1 = (wxWindow *) 0 ;
33179 wxSize *arg2 = 0 ;
33180 void *argp1 = 0 ;
33181 int res1 = 0 ;
33182 wxSize temp2 ;
33183 PyObject * obj0 = 0 ;
33184 PyObject * obj1 = 0 ;
33185 char * kwnames[] = {
33186 (char *) "self",(char *) "size", NULL
33187 };
33188
33189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33191 if (!SWIG_IsOK(res1)) {
33192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33193 }
33194 arg1 = reinterpret_cast< wxWindow * >(argp1);
33195 {
33196 arg2 = &temp2;
33197 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33198 }
33199 {
33200 PyThreadState* __tstate = wxPyBeginAllowThreads();
33201 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33202 wxPyEndAllowThreads(__tstate);
33203 if (PyErr_Occurred()) SWIG_fail;
33204 }
33205 resultobj = SWIG_Py_Void();
33206 return resultobj;
33207 fail:
33208 return NULL;
33209 }
33210
33211
33212 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33213 PyObject *resultobj = 0;
33214 wxWindow *arg1 = (wxWindow *) 0 ;
33215 int arg2 ;
33216 int arg3 ;
33217 void *argp1 = 0 ;
33218 int res1 = 0 ;
33219 int val2 ;
33220 int ecode2 = 0 ;
33221 int val3 ;
33222 int ecode3 = 0 ;
33223 PyObject * obj0 = 0 ;
33224 PyObject * obj1 = 0 ;
33225 PyObject * obj2 = 0 ;
33226 char * kwnames[] = {
33227 (char *) "self",(char *) "w",(char *) "h", NULL
33228 };
33229
33230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33232 if (!SWIG_IsOK(res1)) {
33233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33234 }
33235 arg1 = reinterpret_cast< wxWindow * >(argp1);
33236 ecode2 = SWIG_AsVal_int(obj1, &val2);
33237 if (!SWIG_IsOK(ecode2)) {
33238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33239 }
33240 arg2 = static_cast< int >(val2);
33241 ecode3 = SWIG_AsVal_int(obj2, &val3);
33242 if (!SWIG_IsOK(ecode3)) {
33243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33244 }
33245 arg3 = static_cast< int >(val3);
33246 {
33247 PyThreadState* __tstate = wxPyBeginAllowThreads();
33248 (arg1)->SetVirtualSize(arg2,arg3);
33249 wxPyEndAllowThreads(__tstate);
33250 if (PyErr_Occurred()) SWIG_fail;
33251 }
33252 resultobj = SWIG_Py_Void();
33253 return resultobj;
33254 fail:
33255 return NULL;
33256 }
33257
33258
33259 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33260 PyObject *resultobj = 0;
33261 wxWindow *arg1 = (wxWindow *) 0 ;
33262 wxSize result;
33263 void *argp1 = 0 ;
33264 int res1 = 0 ;
33265 PyObject *swig_obj[1] ;
33266
33267 if (!args) SWIG_fail;
33268 swig_obj[0] = args;
33269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33270 if (!SWIG_IsOK(res1)) {
33271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33272 }
33273 arg1 = reinterpret_cast< wxWindow * >(argp1);
33274 {
33275 PyThreadState* __tstate = wxPyBeginAllowThreads();
33276 result = ((wxWindow const *)arg1)->GetVirtualSize();
33277 wxPyEndAllowThreads(__tstate);
33278 if (PyErr_Occurred()) SWIG_fail;
33279 }
33280 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33281 return resultobj;
33282 fail:
33283 return NULL;
33284 }
33285
33286
33287 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33288 PyObject *resultobj = 0;
33289 wxWindow *arg1 = (wxWindow *) 0 ;
33290 int *arg2 = (int *) 0 ;
33291 int *arg3 = (int *) 0 ;
33292 void *argp1 = 0 ;
33293 int res1 = 0 ;
33294 int temp2 ;
33295 int res2 = SWIG_TMPOBJ ;
33296 int temp3 ;
33297 int res3 = SWIG_TMPOBJ ;
33298 PyObject *swig_obj[1] ;
33299
33300 arg2 = &temp2;
33301 arg3 = &temp3;
33302 if (!args) SWIG_fail;
33303 swig_obj[0] = args;
33304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33305 if (!SWIG_IsOK(res1)) {
33306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33307 }
33308 arg1 = reinterpret_cast< wxWindow * >(argp1);
33309 {
33310 PyThreadState* __tstate = wxPyBeginAllowThreads();
33311 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 resultobj = SWIG_Py_Void();
33316 if (SWIG_IsTmpObj(res2)) {
33317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33318 } else {
33319 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33321 }
33322 if (SWIG_IsTmpObj(res3)) {
33323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33324 } else {
33325 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33327 }
33328 return resultobj;
33329 fail:
33330 return NULL;
33331 }
33332
33333
33334 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33335 PyObject *resultobj = 0;
33336 wxWindow *arg1 = (wxWindow *) 0 ;
33337 wxSize result;
33338 void *argp1 = 0 ;
33339 int res1 = 0 ;
33340 PyObject *swig_obj[1] ;
33341
33342 if (!args) SWIG_fail;
33343 swig_obj[0] = args;
33344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33345 if (!SWIG_IsOK(res1)) {
33346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33347 }
33348 arg1 = reinterpret_cast< wxWindow * >(argp1);
33349 {
33350 PyThreadState* __tstate = wxPyBeginAllowThreads();
33351 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33352 wxPyEndAllowThreads(__tstate);
33353 if (PyErr_Occurred()) SWIG_fail;
33354 }
33355 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33356 return resultobj;
33357 fail:
33358 return NULL;
33359 }
33360
33361
33362 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33363 PyObject *resultobj = 0;
33364 wxWindow *arg1 = (wxWindow *) 0 ;
33365 bool arg2 = (bool) true ;
33366 bool result;
33367 void *argp1 = 0 ;
33368 int res1 = 0 ;
33369 bool val2 ;
33370 int ecode2 = 0 ;
33371 PyObject * obj0 = 0 ;
33372 PyObject * obj1 = 0 ;
33373 char * kwnames[] = {
33374 (char *) "self",(char *) "show", NULL
33375 };
33376
33377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33379 if (!SWIG_IsOK(res1)) {
33380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33381 }
33382 arg1 = reinterpret_cast< wxWindow * >(argp1);
33383 if (obj1) {
33384 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33385 if (!SWIG_IsOK(ecode2)) {
33386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33387 }
33388 arg2 = static_cast< bool >(val2);
33389 }
33390 {
33391 PyThreadState* __tstate = wxPyBeginAllowThreads();
33392 result = (bool)(arg1)->Show(arg2);
33393 wxPyEndAllowThreads(__tstate);
33394 if (PyErr_Occurred()) SWIG_fail;
33395 }
33396 {
33397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33398 }
33399 return resultobj;
33400 fail:
33401 return NULL;
33402 }
33403
33404
33405 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33406 PyObject *resultobj = 0;
33407 wxWindow *arg1 = (wxWindow *) 0 ;
33408 bool result;
33409 void *argp1 = 0 ;
33410 int res1 = 0 ;
33411 PyObject *swig_obj[1] ;
33412
33413 if (!args) SWIG_fail;
33414 swig_obj[0] = args;
33415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33416 if (!SWIG_IsOK(res1)) {
33417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33418 }
33419 arg1 = reinterpret_cast< wxWindow * >(argp1);
33420 {
33421 PyThreadState* __tstate = wxPyBeginAllowThreads();
33422 result = (bool)(arg1)->Hide();
33423 wxPyEndAllowThreads(__tstate);
33424 if (PyErr_Occurred()) SWIG_fail;
33425 }
33426 {
33427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33428 }
33429 return resultobj;
33430 fail:
33431 return NULL;
33432 }
33433
33434
33435 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33436 PyObject *resultobj = 0;
33437 wxWindow *arg1 = (wxWindow *) 0 ;
33438 bool arg2 = (bool) true ;
33439 bool result;
33440 void *argp1 = 0 ;
33441 int res1 = 0 ;
33442 bool val2 ;
33443 int ecode2 = 0 ;
33444 PyObject * obj0 = 0 ;
33445 PyObject * obj1 = 0 ;
33446 char * kwnames[] = {
33447 (char *) "self",(char *) "enable", NULL
33448 };
33449
33450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33452 if (!SWIG_IsOK(res1)) {
33453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33454 }
33455 arg1 = reinterpret_cast< wxWindow * >(argp1);
33456 if (obj1) {
33457 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33458 if (!SWIG_IsOK(ecode2)) {
33459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33460 }
33461 arg2 = static_cast< bool >(val2);
33462 }
33463 {
33464 PyThreadState* __tstate = wxPyBeginAllowThreads();
33465 result = (bool)(arg1)->Enable(arg2);
33466 wxPyEndAllowThreads(__tstate);
33467 if (PyErr_Occurred()) SWIG_fail;
33468 }
33469 {
33470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33471 }
33472 return resultobj;
33473 fail:
33474 return NULL;
33475 }
33476
33477
33478 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33479 PyObject *resultobj = 0;
33480 wxWindow *arg1 = (wxWindow *) 0 ;
33481 bool result;
33482 void *argp1 = 0 ;
33483 int res1 = 0 ;
33484 PyObject *swig_obj[1] ;
33485
33486 if (!args) SWIG_fail;
33487 swig_obj[0] = args;
33488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33489 if (!SWIG_IsOK(res1)) {
33490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33491 }
33492 arg1 = reinterpret_cast< wxWindow * >(argp1);
33493 {
33494 PyThreadState* __tstate = wxPyBeginAllowThreads();
33495 result = (bool)(arg1)->Disable();
33496 wxPyEndAllowThreads(__tstate);
33497 if (PyErr_Occurred()) SWIG_fail;
33498 }
33499 {
33500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33501 }
33502 return resultobj;
33503 fail:
33504 return NULL;
33505 }
33506
33507
33508 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33509 PyObject *resultobj = 0;
33510 wxWindow *arg1 = (wxWindow *) 0 ;
33511 bool result;
33512 void *argp1 = 0 ;
33513 int res1 = 0 ;
33514 PyObject *swig_obj[1] ;
33515
33516 if (!args) SWIG_fail;
33517 swig_obj[0] = args;
33518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33519 if (!SWIG_IsOK(res1)) {
33520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33521 }
33522 arg1 = reinterpret_cast< wxWindow * >(argp1);
33523 {
33524 PyThreadState* __tstate = wxPyBeginAllowThreads();
33525 result = (bool)((wxWindow const *)arg1)->IsShown();
33526 wxPyEndAllowThreads(__tstate);
33527 if (PyErr_Occurred()) SWIG_fail;
33528 }
33529 {
33530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33531 }
33532 return resultobj;
33533 fail:
33534 return NULL;
33535 }
33536
33537
33538 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33539 PyObject *resultobj = 0;
33540 wxWindow *arg1 = (wxWindow *) 0 ;
33541 bool result;
33542 void *argp1 = 0 ;
33543 int res1 = 0 ;
33544 PyObject *swig_obj[1] ;
33545
33546 if (!args) SWIG_fail;
33547 swig_obj[0] = args;
33548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33549 if (!SWIG_IsOK(res1)) {
33550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33551 }
33552 arg1 = reinterpret_cast< wxWindow * >(argp1);
33553 {
33554 PyThreadState* __tstate = wxPyBeginAllowThreads();
33555 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33556 wxPyEndAllowThreads(__tstate);
33557 if (PyErr_Occurred()) SWIG_fail;
33558 }
33559 {
33560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33561 }
33562 return resultobj;
33563 fail:
33564 return NULL;
33565 }
33566
33567
33568 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33569 PyObject *resultobj = 0;
33570 wxWindow *arg1 = (wxWindow *) 0 ;
33571 bool result;
33572 void *argp1 = 0 ;
33573 int res1 = 0 ;
33574 PyObject *swig_obj[1] ;
33575
33576 if (!args) SWIG_fail;
33577 swig_obj[0] = args;
33578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33579 if (!SWIG_IsOK(res1)) {
33580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33581 }
33582 arg1 = reinterpret_cast< wxWindow * >(argp1);
33583 {
33584 PyThreadState* __tstate = wxPyBeginAllowThreads();
33585 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33586 wxPyEndAllowThreads(__tstate);
33587 if (PyErr_Occurred()) SWIG_fail;
33588 }
33589 {
33590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33591 }
33592 return resultobj;
33593 fail:
33594 return NULL;
33595 }
33596
33597
33598 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33599 PyObject *resultobj = 0;
33600 wxWindow *arg1 = (wxWindow *) 0 ;
33601 long arg2 ;
33602 void *argp1 = 0 ;
33603 int res1 = 0 ;
33604 long val2 ;
33605 int ecode2 = 0 ;
33606 PyObject * obj0 = 0 ;
33607 PyObject * obj1 = 0 ;
33608 char * kwnames[] = {
33609 (char *) "self",(char *) "style", NULL
33610 };
33611
33612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33614 if (!SWIG_IsOK(res1)) {
33615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33616 }
33617 arg1 = reinterpret_cast< wxWindow * >(argp1);
33618 ecode2 = SWIG_AsVal_long(obj1, &val2);
33619 if (!SWIG_IsOK(ecode2)) {
33620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33621 }
33622 arg2 = static_cast< long >(val2);
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 (arg1)->SetWindowStyleFlag(arg2);
33626 wxPyEndAllowThreads(__tstate);
33627 if (PyErr_Occurred()) SWIG_fail;
33628 }
33629 resultobj = SWIG_Py_Void();
33630 return resultobj;
33631 fail:
33632 return NULL;
33633 }
33634
33635
33636 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33637 PyObject *resultobj = 0;
33638 wxWindow *arg1 = (wxWindow *) 0 ;
33639 long result;
33640 void *argp1 = 0 ;
33641 int res1 = 0 ;
33642 PyObject *swig_obj[1] ;
33643
33644 if (!args) SWIG_fail;
33645 swig_obj[0] = args;
33646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33647 if (!SWIG_IsOK(res1)) {
33648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33649 }
33650 arg1 = reinterpret_cast< wxWindow * >(argp1);
33651 {
33652 PyThreadState* __tstate = wxPyBeginAllowThreads();
33653 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33654 wxPyEndAllowThreads(__tstate);
33655 if (PyErr_Occurred()) SWIG_fail;
33656 }
33657 resultobj = SWIG_From_long(static_cast< long >(result));
33658 return resultobj;
33659 fail:
33660 return NULL;
33661 }
33662
33663
33664 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33665 PyObject *resultobj = 0;
33666 wxWindow *arg1 = (wxWindow *) 0 ;
33667 int arg2 ;
33668 bool result;
33669 void *argp1 = 0 ;
33670 int res1 = 0 ;
33671 int val2 ;
33672 int ecode2 = 0 ;
33673 PyObject * obj0 = 0 ;
33674 PyObject * obj1 = 0 ;
33675 char * kwnames[] = {
33676 (char *) "self",(char *) "flag", NULL
33677 };
33678
33679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33681 if (!SWIG_IsOK(res1)) {
33682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33683 }
33684 arg1 = reinterpret_cast< wxWindow * >(argp1);
33685 ecode2 = SWIG_AsVal_int(obj1, &val2);
33686 if (!SWIG_IsOK(ecode2)) {
33687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33688 }
33689 arg2 = static_cast< int >(val2);
33690 {
33691 PyThreadState* __tstate = wxPyBeginAllowThreads();
33692 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33693 wxPyEndAllowThreads(__tstate);
33694 if (PyErr_Occurred()) SWIG_fail;
33695 }
33696 {
33697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33698 }
33699 return resultobj;
33700 fail:
33701 return NULL;
33702 }
33703
33704
33705 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33706 PyObject *resultobj = 0;
33707 wxWindow *arg1 = (wxWindow *) 0 ;
33708 bool result;
33709 void *argp1 = 0 ;
33710 int res1 = 0 ;
33711 PyObject *swig_obj[1] ;
33712
33713 if (!args) SWIG_fail;
33714 swig_obj[0] = args;
33715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33716 if (!SWIG_IsOK(res1)) {
33717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33718 }
33719 arg1 = reinterpret_cast< wxWindow * >(argp1);
33720 {
33721 PyThreadState* __tstate = wxPyBeginAllowThreads();
33722 result = (bool)((wxWindow const *)arg1)->IsRetained();
33723 wxPyEndAllowThreads(__tstate);
33724 if (PyErr_Occurred()) SWIG_fail;
33725 }
33726 {
33727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33728 }
33729 return resultobj;
33730 fail:
33731 return NULL;
33732 }
33733
33734
33735 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33736 PyObject *resultobj = 0;
33737 wxWindow *arg1 = (wxWindow *) 0 ;
33738 long arg2 ;
33739 void *argp1 = 0 ;
33740 int res1 = 0 ;
33741 long val2 ;
33742 int ecode2 = 0 ;
33743 PyObject * obj0 = 0 ;
33744 PyObject * obj1 = 0 ;
33745 char * kwnames[] = {
33746 (char *) "self",(char *) "exStyle", NULL
33747 };
33748
33749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33751 if (!SWIG_IsOK(res1)) {
33752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33753 }
33754 arg1 = reinterpret_cast< wxWindow * >(argp1);
33755 ecode2 = SWIG_AsVal_long(obj1, &val2);
33756 if (!SWIG_IsOK(ecode2)) {
33757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33758 }
33759 arg2 = static_cast< long >(val2);
33760 {
33761 PyThreadState* __tstate = wxPyBeginAllowThreads();
33762 (arg1)->SetExtraStyle(arg2);
33763 wxPyEndAllowThreads(__tstate);
33764 if (PyErr_Occurred()) SWIG_fail;
33765 }
33766 resultobj = SWIG_Py_Void();
33767 return resultobj;
33768 fail:
33769 return NULL;
33770 }
33771
33772
33773 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33774 PyObject *resultobj = 0;
33775 wxWindow *arg1 = (wxWindow *) 0 ;
33776 long result;
33777 void *argp1 = 0 ;
33778 int res1 = 0 ;
33779 PyObject *swig_obj[1] ;
33780
33781 if (!args) SWIG_fail;
33782 swig_obj[0] = args;
33783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33784 if (!SWIG_IsOK(res1)) {
33785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33786 }
33787 arg1 = reinterpret_cast< wxWindow * >(argp1);
33788 {
33789 PyThreadState* __tstate = wxPyBeginAllowThreads();
33790 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33791 wxPyEndAllowThreads(__tstate);
33792 if (PyErr_Occurred()) SWIG_fail;
33793 }
33794 resultobj = SWIG_From_long(static_cast< long >(result));
33795 return resultobj;
33796 fail:
33797 return NULL;
33798 }
33799
33800
33801 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33802 PyObject *resultobj = 0;
33803 wxWindow *arg1 = (wxWindow *) 0 ;
33804 bool arg2 = (bool) true ;
33805 void *argp1 = 0 ;
33806 int res1 = 0 ;
33807 bool val2 ;
33808 int ecode2 = 0 ;
33809 PyObject * obj0 = 0 ;
33810 PyObject * obj1 = 0 ;
33811 char * kwnames[] = {
33812 (char *) "self",(char *) "modal", NULL
33813 };
33814
33815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33817 if (!SWIG_IsOK(res1)) {
33818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33819 }
33820 arg1 = reinterpret_cast< wxWindow * >(argp1);
33821 if (obj1) {
33822 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33823 if (!SWIG_IsOK(ecode2)) {
33824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33825 }
33826 arg2 = static_cast< bool >(val2);
33827 }
33828 {
33829 PyThreadState* __tstate = wxPyBeginAllowThreads();
33830 (arg1)->MakeModal(arg2);
33831 wxPyEndAllowThreads(__tstate);
33832 if (PyErr_Occurred()) SWIG_fail;
33833 }
33834 resultobj = SWIG_Py_Void();
33835 return resultobj;
33836 fail:
33837 return NULL;
33838 }
33839
33840
33841 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33842 PyObject *resultobj = 0;
33843 wxWindow *arg1 = (wxWindow *) 0 ;
33844 bool arg2 ;
33845 void *argp1 = 0 ;
33846 int res1 = 0 ;
33847 bool val2 ;
33848 int ecode2 = 0 ;
33849 PyObject * obj0 = 0 ;
33850 PyObject * obj1 = 0 ;
33851 char * kwnames[] = {
33852 (char *) "self",(char *) "enableTheme", NULL
33853 };
33854
33855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33857 if (!SWIG_IsOK(res1)) {
33858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33859 }
33860 arg1 = reinterpret_cast< wxWindow * >(argp1);
33861 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33862 if (!SWIG_IsOK(ecode2)) {
33863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33864 }
33865 arg2 = static_cast< bool >(val2);
33866 {
33867 PyThreadState* __tstate = wxPyBeginAllowThreads();
33868 (arg1)->SetThemeEnabled(arg2);
33869 wxPyEndAllowThreads(__tstate);
33870 if (PyErr_Occurred()) SWIG_fail;
33871 }
33872 resultobj = SWIG_Py_Void();
33873 return resultobj;
33874 fail:
33875 return NULL;
33876 }
33877
33878
33879 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33880 PyObject *resultobj = 0;
33881 wxWindow *arg1 = (wxWindow *) 0 ;
33882 bool result;
33883 void *argp1 = 0 ;
33884 int res1 = 0 ;
33885 PyObject *swig_obj[1] ;
33886
33887 if (!args) SWIG_fail;
33888 swig_obj[0] = args;
33889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33890 if (!SWIG_IsOK(res1)) {
33891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33892 }
33893 arg1 = reinterpret_cast< wxWindow * >(argp1);
33894 {
33895 PyThreadState* __tstate = wxPyBeginAllowThreads();
33896 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33897 wxPyEndAllowThreads(__tstate);
33898 if (PyErr_Occurred()) SWIG_fail;
33899 }
33900 {
33901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33902 }
33903 return resultobj;
33904 fail:
33905 return NULL;
33906 }
33907
33908
33909 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33910 PyObject *resultobj = 0;
33911 wxWindow *arg1 = (wxWindow *) 0 ;
33912 void *argp1 = 0 ;
33913 int res1 = 0 ;
33914 PyObject *swig_obj[1] ;
33915
33916 if (!args) SWIG_fail;
33917 swig_obj[0] = args;
33918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33919 if (!SWIG_IsOK(res1)) {
33920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33921 }
33922 arg1 = reinterpret_cast< wxWindow * >(argp1);
33923 {
33924 PyThreadState* __tstate = wxPyBeginAllowThreads();
33925 (arg1)->SetFocus();
33926 wxPyEndAllowThreads(__tstate);
33927 if (PyErr_Occurred()) SWIG_fail;
33928 }
33929 resultobj = SWIG_Py_Void();
33930 return resultobj;
33931 fail:
33932 return NULL;
33933 }
33934
33935
33936 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33937 PyObject *resultobj = 0;
33938 wxWindow *arg1 = (wxWindow *) 0 ;
33939 void *argp1 = 0 ;
33940 int res1 = 0 ;
33941 PyObject *swig_obj[1] ;
33942
33943 if (!args) SWIG_fail;
33944 swig_obj[0] = args;
33945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33946 if (!SWIG_IsOK(res1)) {
33947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33948 }
33949 arg1 = reinterpret_cast< wxWindow * >(argp1);
33950 {
33951 PyThreadState* __tstate = wxPyBeginAllowThreads();
33952 (arg1)->SetFocusFromKbd();
33953 wxPyEndAllowThreads(__tstate);
33954 if (PyErr_Occurred()) SWIG_fail;
33955 }
33956 resultobj = SWIG_Py_Void();
33957 return resultobj;
33958 fail:
33959 return NULL;
33960 }
33961
33962
33963 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33964 PyObject *resultobj = 0;
33965 wxWindow *result = 0 ;
33966
33967 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33968 {
33969 if (!wxPyCheckForApp()) SWIG_fail;
33970 PyThreadState* __tstate = wxPyBeginAllowThreads();
33971 result = (wxWindow *)wxWindow::FindFocus();
33972 wxPyEndAllowThreads(__tstate);
33973 if (PyErr_Occurred()) SWIG_fail;
33974 }
33975 {
33976 resultobj = wxPyMake_wxObject(result, 0);
33977 }
33978 return resultobj;
33979 fail:
33980 return NULL;
33981 }
33982
33983
33984 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33985 PyObject *resultobj = 0;
33986 wxWindow *arg1 = (wxWindow *) 0 ;
33987 bool result;
33988 void *argp1 = 0 ;
33989 int res1 = 0 ;
33990 PyObject *swig_obj[1] ;
33991
33992 if (!args) SWIG_fail;
33993 swig_obj[0] = args;
33994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33995 if (!SWIG_IsOK(res1)) {
33996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33997 }
33998 arg1 = reinterpret_cast< wxWindow * >(argp1);
33999 {
34000 PyThreadState* __tstate = wxPyBeginAllowThreads();
34001 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
34002 wxPyEndAllowThreads(__tstate);
34003 if (PyErr_Occurred()) SWIG_fail;
34004 }
34005 {
34006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34007 }
34008 return resultobj;
34009 fail:
34010 return NULL;
34011 }
34012
34013
34014 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34015 PyObject *resultobj = 0;
34016 wxWindow *arg1 = (wxWindow *) 0 ;
34017 bool result;
34018 void *argp1 = 0 ;
34019 int res1 = 0 ;
34020 PyObject *swig_obj[1] ;
34021
34022 if (!args) SWIG_fail;
34023 swig_obj[0] = args;
34024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34025 if (!SWIG_IsOK(res1)) {
34026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
34027 }
34028 arg1 = reinterpret_cast< wxWindow * >(argp1);
34029 {
34030 PyThreadState* __tstate = wxPyBeginAllowThreads();
34031 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
34032 wxPyEndAllowThreads(__tstate);
34033 if (PyErr_Occurred()) SWIG_fail;
34034 }
34035 {
34036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34037 }
34038 return resultobj;
34039 fail:
34040 return NULL;
34041 }
34042
34043
34044 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34045 PyObject *resultobj = 0;
34046 wxWindow *arg1 = (wxWindow *) 0 ;
34047 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
34048 bool result;
34049 void *argp1 = 0 ;
34050 int res1 = 0 ;
34051 int val2 ;
34052 int ecode2 = 0 ;
34053 PyObject * obj0 = 0 ;
34054 PyObject * obj1 = 0 ;
34055 char * kwnames[] = {
34056 (char *) "self",(char *) "flags", NULL
34057 };
34058
34059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
34060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34061 if (!SWIG_IsOK(res1)) {
34062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
34063 }
34064 arg1 = reinterpret_cast< wxWindow * >(argp1);
34065 if (obj1) {
34066 ecode2 = SWIG_AsVal_int(obj1, &val2);
34067 if (!SWIG_IsOK(ecode2)) {
34068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
34069 }
34070 arg2 = static_cast< int >(val2);
34071 }
34072 {
34073 PyThreadState* __tstate = wxPyBeginAllowThreads();
34074 result = (bool)(arg1)->Navigate(arg2);
34075 wxPyEndAllowThreads(__tstate);
34076 if (PyErr_Occurred()) SWIG_fail;
34077 }
34078 {
34079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34080 }
34081 return resultobj;
34082 fail:
34083 return NULL;
34084 }
34085
34086
34087 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34088 PyObject *resultobj = 0;
34089 wxWindow *arg1 = (wxWindow *) 0 ;
34090 wxWindow *arg2 = (wxWindow *) 0 ;
34091 void *argp1 = 0 ;
34092 int res1 = 0 ;
34093 void *argp2 = 0 ;
34094 int res2 = 0 ;
34095 PyObject * obj0 = 0 ;
34096 PyObject * obj1 = 0 ;
34097 char * kwnames[] = {
34098 (char *) "self",(char *) "win", NULL
34099 };
34100
34101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34103 if (!SWIG_IsOK(res1)) {
34104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34105 }
34106 arg1 = reinterpret_cast< wxWindow * >(argp1);
34107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34108 if (!SWIG_IsOK(res2)) {
34109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34110 }
34111 arg2 = reinterpret_cast< wxWindow * >(argp2);
34112 {
34113 PyThreadState* __tstate = wxPyBeginAllowThreads();
34114 (arg1)->MoveAfterInTabOrder(arg2);
34115 wxPyEndAllowThreads(__tstate);
34116 if (PyErr_Occurred()) SWIG_fail;
34117 }
34118 resultobj = SWIG_Py_Void();
34119 return resultobj;
34120 fail:
34121 return NULL;
34122 }
34123
34124
34125 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34126 PyObject *resultobj = 0;
34127 wxWindow *arg1 = (wxWindow *) 0 ;
34128 wxWindow *arg2 = (wxWindow *) 0 ;
34129 void *argp1 = 0 ;
34130 int res1 = 0 ;
34131 void *argp2 = 0 ;
34132 int res2 = 0 ;
34133 PyObject * obj0 = 0 ;
34134 PyObject * obj1 = 0 ;
34135 char * kwnames[] = {
34136 (char *) "self",(char *) "win", NULL
34137 };
34138
34139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34141 if (!SWIG_IsOK(res1)) {
34142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34143 }
34144 arg1 = reinterpret_cast< wxWindow * >(argp1);
34145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34146 if (!SWIG_IsOK(res2)) {
34147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34148 }
34149 arg2 = reinterpret_cast< wxWindow * >(argp2);
34150 {
34151 PyThreadState* __tstate = wxPyBeginAllowThreads();
34152 (arg1)->MoveBeforeInTabOrder(arg2);
34153 wxPyEndAllowThreads(__tstate);
34154 if (PyErr_Occurred()) SWIG_fail;
34155 }
34156 resultobj = SWIG_Py_Void();
34157 return resultobj;
34158 fail:
34159 return NULL;
34160 }
34161
34162
34163 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34164 PyObject *resultobj = 0;
34165 wxWindow *arg1 = (wxWindow *) 0 ;
34166 PyObject *result = 0 ;
34167 void *argp1 = 0 ;
34168 int res1 = 0 ;
34169 PyObject *swig_obj[1] ;
34170
34171 if (!args) SWIG_fail;
34172 swig_obj[0] = args;
34173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34174 if (!SWIG_IsOK(res1)) {
34175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34176 }
34177 arg1 = reinterpret_cast< wxWindow * >(argp1);
34178 {
34179 PyThreadState* __tstate = wxPyBeginAllowThreads();
34180 result = (PyObject *)wxWindow_GetChildren(arg1);
34181 wxPyEndAllowThreads(__tstate);
34182 if (PyErr_Occurred()) SWIG_fail;
34183 }
34184 resultobj = result;
34185 return resultobj;
34186 fail:
34187 return NULL;
34188 }
34189
34190
34191 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34192 PyObject *resultobj = 0;
34193 wxWindow *arg1 = (wxWindow *) 0 ;
34194 wxWindow *result = 0 ;
34195 void *argp1 = 0 ;
34196 int res1 = 0 ;
34197 PyObject *swig_obj[1] ;
34198
34199 if (!args) SWIG_fail;
34200 swig_obj[0] = args;
34201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34202 if (!SWIG_IsOK(res1)) {
34203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34204 }
34205 arg1 = reinterpret_cast< wxWindow * >(argp1);
34206 {
34207 PyThreadState* __tstate = wxPyBeginAllowThreads();
34208 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34209 wxPyEndAllowThreads(__tstate);
34210 if (PyErr_Occurred()) SWIG_fail;
34211 }
34212 {
34213 resultobj = wxPyMake_wxObject(result, 0);
34214 }
34215 return resultobj;
34216 fail:
34217 return NULL;
34218 }
34219
34220
34221 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34222 PyObject *resultobj = 0;
34223 wxWindow *arg1 = (wxWindow *) 0 ;
34224 wxWindow *result = 0 ;
34225 void *argp1 = 0 ;
34226 int res1 = 0 ;
34227 PyObject *swig_obj[1] ;
34228
34229 if (!args) SWIG_fail;
34230 swig_obj[0] = args;
34231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34232 if (!SWIG_IsOK(res1)) {
34233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34234 }
34235 arg1 = reinterpret_cast< wxWindow * >(argp1);
34236 {
34237 PyThreadState* __tstate = wxPyBeginAllowThreads();
34238 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34239 wxPyEndAllowThreads(__tstate);
34240 if (PyErr_Occurred()) SWIG_fail;
34241 }
34242 {
34243 resultobj = wxPyMake_wxObject(result, 0);
34244 }
34245 return resultobj;
34246 fail:
34247 return NULL;
34248 }
34249
34250
34251 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34252 PyObject *resultobj = 0;
34253 wxWindow *arg1 = (wxWindow *) 0 ;
34254 bool result;
34255 void *argp1 = 0 ;
34256 int res1 = 0 ;
34257 PyObject *swig_obj[1] ;
34258
34259 if (!args) SWIG_fail;
34260 swig_obj[0] = args;
34261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34262 if (!SWIG_IsOK(res1)) {
34263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34264 }
34265 arg1 = reinterpret_cast< wxWindow * >(argp1);
34266 {
34267 PyThreadState* __tstate = wxPyBeginAllowThreads();
34268 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34269 wxPyEndAllowThreads(__tstate);
34270 if (PyErr_Occurred()) SWIG_fail;
34271 }
34272 {
34273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34274 }
34275 return resultobj;
34276 fail:
34277 return NULL;
34278 }
34279
34280
34281 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34282 PyObject *resultobj = 0;
34283 wxWindow *arg1 = (wxWindow *) 0 ;
34284 wxWindow *arg2 = (wxWindow *) 0 ;
34285 bool result;
34286 void *argp1 = 0 ;
34287 int res1 = 0 ;
34288 void *argp2 = 0 ;
34289 int res2 = 0 ;
34290 PyObject * obj0 = 0 ;
34291 PyObject * obj1 = 0 ;
34292 char * kwnames[] = {
34293 (char *) "self",(char *) "newParent", NULL
34294 };
34295
34296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34298 if (!SWIG_IsOK(res1)) {
34299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34300 }
34301 arg1 = reinterpret_cast< wxWindow * >(argp1);
34302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34303 if (!SWIG_IsOK(res2)) {
34304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34305 }
34306 arg2 = reinterpret_cast< wxWindow * >(argp2);
34307 {
34308 PyThreadState* __tstate = wxPyBeginAllowThreads();
34309 result = (bool)(arg1)->Reparent(arg2);
34310 wxPyEndAllowThreads(__tstate);
34311 if (PyErr_Occurred()) SWIG_fail;
34312 }
34313 {
34314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34315 }
34316 return resultobj;
34317 fail:
34318 return NULL;
34319 }
34320
34321
34322 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34323 PyObject *resultobj = 0;
34324 wxWindow *arg1 = (wxWindow *) 0 ;
34325 wxWindow *arg2 = (wxWindow *) 0 ;
34326 void *argp1 = 0 ;
34327 int res1 = 0 ;
34328 void *argp2 = 0 ;
34329 int res2 = 0 ;
34330 PyObject * obj0 = 0 ;
34331 PyObject * obj1 = 0 ;
34332 char * kwnames[] = {
34333 (char *) "self",(char *) "child", NULL
34334 };
34335
34336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34338 if (!SWIG_IsOK(res1)) {
34339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34340 }
34341 arg1 = reinterpret_cast< wxWindow * >(argp1);
34342 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34343 if (!SWIG_IsOK(res2)) {
34344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34345 }
34346 arg2 = reinterpret_cast< wxWindow * >(argp2);
34347 {
34348 PyThreadState* __tstate = wxPyBeginAllowThreads();
34349 (arg1)->AddChild(arg2);
34350 wxPyEndAllowThreads(__tstate);
34351 if (PyErr_Occurred()) SWIG_fail;
34352 }
34353 resultobj = SWIG_Py_Void();
34354 return resultobj;
34355 fail:
34356 return NULL;
34357 }
34358
34359
34360 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34361 PyObject *resultobj = 0;
34362 wxWindow *arg1 = (wxWindow *) 0 ;
34363 wxWindow *arg2 = (wxWindow *) 0 ;
34364 void *argp1 = 0 ;
34365 int res1 = 0 ;
34366 void *argp2 = 0 ;
34367 int res2 = 0 ;
34368 PyObject * obj0 = 0 ;
34369 PyObject * obj1 = 0 ;
34370 char * kwnames[] = {
34371 (char *) "self",(char *) "child", NULL
34372 };
34373
34374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34376 if (!SWIG_IsOK(res1)) {
34377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34378 }
34379 arg1 = reinterpret_cast< wxWindow * >(argp1);
34380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34381 if (!SWIG_IsOK(res2)) {
34382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34383 }
34384 arg2 = reinterpret_cast< wxWindow * >(argp2);
34385 {
34386 PyThreadState* __tstate = wxPyBeginAllowThreads();
34387 (arg1)->RemoveChild(arg2);
34388 wxPyEndAllowThreads(__tstate);
34389 if (PyErr_Occurred()) SWIG_fail;
34390 }
34391 resultobj = SWIG_Py_Void();
34392 return resultobj;
34393 fail:
34394 return NULL;
34395 }
34396
34397
34398 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34399 PyObject *resultobj = 0;
34400 wxWindow *arg1 = (wxWindow *) 0 ;
34401 bool arg2 ;
34402 void *argp1 = 0 ;
34403 int res1 = 0 ;
34404 bool val2 ;
34405 int ecode2 = 0 ;
34406 PyObject * obj0 = 0 ;
34407 PyObject * obj1 = 0 ;
34408 char * kwnames[] = {
34409 (char *) "self",(char *) "on", NULL
34410 };
34411
34412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34414 if (!SWIG_IsOK(res1)) {
34415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34416 }
34417 arg1 = reinterpret_cast< wxWindow * >(argp1);
34418 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34419 if (!SWIG_IsOK(ecode2)) {
34420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34421 }
34422 arg2 = static_cast< bool >(val2);
34423 {
34424 PyThreadState* __tstate = wxPyBeginAllowThreads();
34425 wxWindow_SetDoubleBuffered(arg1,arg2);
34426 wxPyEndAllowThreads(__tstate);
34427 if (PyErr_Occurred()) SWIG_fail;
34428 }
34429 resultobj = SWIG_Py_Void();
34430 return resultobj;
34431 fail:
34432 return NULL;
34433 }
34434
34435
34436 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34437 PyObject *resultobj = 0;
34438 wxWindow *arg1 = (wxWindow *) 0 ;
34439 long arg2 ;
34440 wxWindow *result = 0 ;
34441 void *argp1 = 0 ;
34442 int res1 = 0 ;
34443 long val2 ;
34444 int ecode2 = 0 ;
34445 PyObject * obj0 = 0 ;
34446 PyObject * obj1 = 0 ;
34447 char * kwnames[] = {
34448 (char *) "self",(char *) "winid", NULL
34449 };
34450
34451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34453 if (!SWIG_IsOK(res1)) {
34454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34455 }
34456 arg1 = reinterpret_cast< wxWindow * >(argp1);
34457 ecode2 = SWIG_AsVal_long(obj1, &val2);
34458 if (!SWIG_IsOK(ecode2)) {
34459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34460 }
34461 arg2 = static_cast< long >(val2);
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 result = (wxWindow *)(arg1)->FindWindow(arg2);
34465 wxPyEndAllowThreads(__tstate);
34466 if (PyErr_Occurred()) SWIG_fail;
34467 }
34468 {
34469 resultobj = wxPyMake_wxObject(result, 0);
34470 }
34471 return resultobj;
34472 fail:
34473 return NULL;
34474 }
34475
34476
34477 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34478 PyObject *resultobj = 0;
34479 wxWindow *arg1 = (wxWindow *) 0 ;
34480 wxString *arg2 = 0 ;
34481 wxWindow *result = 0 ;
34482 void *argp1 = 0 ;
34483 int res1 = 0 ;
34484 bool temp2 = false ;
34485 PyObject * obj0 = 0 ;
34486 PyObject * obj1 = 0 ;
34487 char * kwnames[] = {
34488 (char *) "self",(char *) "name", NULL
34489 };
34490
34491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34493 if (!SWIG_IsOK(res1)) {
34494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34495 }
34496 arg1 = reinterpret_cast< wxWindow * >(argp1);
34497 {
34498 arg2 = wxString_in_helper(obj1);
34499 if (arg2 == NULL) SWIG_fail;
34500 temp2 = true;
34501 }
34502 {
34503 PyThreadState* __tstate = wxPyBeginAllowThreads();
34504 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34505 wxPyEndAllowThreads(__tstate);
34506 if (PyErr_Occurred()) SWIG_fail;
34507 }
34508 {
34509 resultobj = wxPyMake_wxObject(result, 0);
34510 }
34511 {
34512 if (temp2)
34513 delete arg2;
34514 }
34515 return resultobj;
34516 fail:
34517 {
34518 if (temp2)
34519 delete arg2;
34520 }
34521 return NULL;
34522 }
34523
34524
34525 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34526 PyObject *resultobj = 0;
34527 wxWindow *arg1 = (wxWindow *) 0 ;
34528 wxEvtHandler *result = 0 ;
34529 void *argp1 = 0 ;
34530 int res1 = 0 ;
34531 PyObject *swig_obj[1] ;
34532
34533 if (!args) SWIG_fail;
34534 swig_obj[0] = args;
34535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34536 if (!SWIG_IsOK(res1)) {
34537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34538 }
34539 arg1 = reinterpret_cast< wxWindow * >(argp1);
34540 {
34541 PyThreadState* __tstate = wxPyBeginAllowThreads();
34542 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34543 wxPyEndAllowThreads(__tstate);
34544 if (PyErr_Occurred()) SWIG_fail;
34545 }
34546 {
34547 resultobj = wxPyMake_wxObject(result, 0);
34548 }
34549 return resultobj;
34550 fail:
34551 return NULL;
34552 }
34553
34554
34555 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34556 PyObject *resultobj = 0;
34557 wxWindow *arg1 = (wxWindow *) 0 ;
34558 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34559 void *argp1 = 0 ;
34560 int res1 = 0 ;
34561 void *argp2 = 0 ;
34562 int res2 = 0 ;
34563 PyObject * obj0 = 0 ;
34564 PyObject * obj1 = 0 ;
34565 char * kwnames[] = {
34566 (char *) "self",(char *) "handler", NULL
34567 };
34568
34569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34571 if (!SWIG_IsOK(res1)) {
34572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34573 }
34574 arg1 = reinterpret_cast< wxWindow * >(argp1);
34575 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34576 if (!SWIG_IsOK(res2)) {
34577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34578 }
34579 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34580 {
34581 PyThreadState* __tstate = wxPyBeginAllowThreads();
34582 (arg1)->SetEventHandler(arg2);
34583 wxPyEndAllowThreads(__tstate);
34584 if (PyErr_Occurred()) SWIG_fail;
34585 }
34586 resultobj = SWIG_Py_Void();
34587 return resultobj;
34588 fail:
34589 return NULL;
34590 }
34591
34592
34593 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34594 PyObject *resultobj = 0;
34595 wxWindow *arg1 = (wxWindow *) 0 ;
34596 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34597 void *argp1 = 0 ;
34598 int res1 = 0 ;
34599 void *argp2 = 0 ;
34600 int res2 = 0 ;
34601 PyObject * obj0 = 0 ;
34602 PyObject * obj1 = 0 ;
34603 char * kwnames[] = {
34604 (char *) "self",(char *) "handler", NULL
34605 };
34606
34607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34609 if (!SWIG_IsOK(res1)) {
34610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34611 }
34612 arg1 = reinterpret_cast< wxWindow * >(argp1);
34613 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34614 if (!SWIG_IsOK(res2)) {
34615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34616 }
34617 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34618 {
34619 PyThreadState* __tstate = wxPyBeginAllowThreads();
34620 (arg1)->PushEventHandler(arg2);
34621 wxPyEndAllowThreads(__tstate);
34622 if (PyErr_Occurred()) SWIG_fail;
34623 }
34624 resultobj = SWIG_Py_Void();
34625 return resultobj;
34626 fail:
34627 return NULL;
34628 }
34629
34630
34631 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34632 PyObject *resultobj = 0;
34633 wxWindow *arg1 = (wxWindow *) 0 ;
34634 bool arg2 = (bool) false ;
34635 wxEvtHandler *result = 0 ;
34636 void *argp1 = 0 ;
34637 int res1 = 0 ;
34638 bool val2 ;
34639 int ecode2 = 0 ;
34640 PyObject * obj0 = 0 ;
34641 PyObject * obj1 = 0 ;
34642 char * kwnames[] = {
34643 (char *) "self",(char *) "deleteHandler", NULL
34644 };
34645
34646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34648 if (!SWIG_IsOK(res1)) {
34649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34650 }
34651 arg1 = reinterpret_cast< wxWindow * >(argp1);
34652 if (obj1) {
34653 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34654 if (!SWIG_IsOK(ecode2)) {
34655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34656 }
34657 arg2 = static_cast< bool >(val2);
34658 }
34659 {
34660 PyThreadState* __tstate = wxPyBeginAllowThreads();
34661 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34662 wxPyEndAllowThreads(__tstate);
34663 if (PyErr_Occurred()) SWIG_fail;
34664 }
34665 {
34666 resultobj = wxPyMake_wxObject(result, 0);
34667 }
34668 return resultobj;
34669 fail:
34670 return NULL;
34671 }
34672
34673
34674 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34675 PyObject *resultobj = 0;
34676 wxWindow *arg1 = (wxWindow *) 0 ;
34677 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34678 bool result;
34679 void *argp1 = 0 ;
34680 int res1 = 0 ;
34681 void *argp2 = 0 ;
34682 int res2 = 0 ;
34683 PyObject * obj0 = 0 ;
34684 PyObject * obj1 = 0 ;
34685 char * kwnames[] = {
34686 (char *) "self",(char *) "handler", NULL
34687 };
34688
34689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34691 if (!SWIG_IsOK(res1)) {
34692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34693 }
34694 arg1 = reinterpret_cast< wxWindow * >(argp1);
34695 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34696 if (!SWIG_IsOK(res2)) {
34697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34698 }
34699 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34700 {
34701 PyThreadState* __tstate = wxPyBeginAllowThreads();
34702 result = (bool)(arg1)->RemoveEventHandler(arg2);
34703 wxPyEndAllowThreads(__tstate);
34704 if (PyErr_Occurred()) SWIG_fail;
34705 }
34706 {
34707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34708 }
34709 return resultobj;
34710 fail:
34711 return NULL;
34712 }
34713
34714
34715 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34716 PyObject *resultobj = 0;
34717 wxWindow *arg1 = (wxWindow *) 0 ;
34718 wxValidator *arg2 = 0 ;
34719 void *argp1 = 0 ;
34720 int res1 = 0 ;
34721 void *argp2 = 0 ;
34722 int res2 = 0 ;
34723 PyObject * obj0 = 0 ;
34724 PyObject * obj1 = 0 ;
34725 char * kwnames[] = {
34726 (char *) "self",(char *) "validator", NULL
34727 };
34728
34729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34731 if (!SWIG_IsOK(res1)) {
34732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34733 }
34734 arg1 = reinterpret_cast< wxWindow * >(argp1);
34735 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34736 if (!SWIG_IsOK(res2)) {
34737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34738 }
34739 if (!argp2) {
34740 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34741 }
34742 arg2 = reinterpret_cast< wxValidator * >(argp2);
34743 {
34744 PyThreadState* __tstate = wxPyBeginAllowThreads();
34745 (arg1)->SetValidator((wxValidator const &)*arg2);
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 resultobj = SWIG_Py_Void();
34750 return resultobj;
34751 fail:
34752 return NULL;
34753 }
34754
34755
34756 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34757 PyObject *resultobj = 0;
34758 wxWindow *arg1 = (wxWindow *) 0 ;
34759 wxValidator *result = 0 ;
34760 void *argp1 = 0 ;
34761 int res1 = 0 ;
34762 PyObject *swig_obj[1] ;
34763
34764 if (!args) SWIG_fail;
34765 swig_obj[0] = args;
34766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34767 if (!SWIG_IsOK(res1)) {
34768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34769 }
34770 arg1 = reinterpret_cast< wxWindow * >(argp1);
34771 {
34772 PyThreadState* __tstate = wxPyBeginAllowThreads();
34773 result = (wxValidator *)(arg1)->GetValidator();
34774 wxPyEndAllowThreads(__tstate);
34775 if (PyErr_Occurred()) SWIG_fail;
34776 }
34777 {
34778 resultobj = wxPyMake_wxObject(result, (bool)0);
34779 }
34780 return resultobj;
34781 fail:
34782 return NULL;
34783 }
34784
34785
34786 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34787 PyObject *resultobj = 0;
34788 wxWindow *arg1 = (wxWindow *) 0 ;
34789 bool result;
34790 void *argp1 = 0 ;
34791 int res1 = 0 ;
34792 PyObject *swig_obj[1] ;
34793
34794 if (!args) SWIG_fail;
34795 swig_obj[0] = args;
34796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34797 if (!SWIG_IsOK(res1)) {
34798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34799 }
34800 arg1 = reinterpret_cast< wxWindow * >(argp1);
34801 {
34802 PyThreadState* __tstate = wxPyBeginAllowThreads();
34803 result = (bool)(arg1)->Validate();
34804 wxPyEndAllowThreads(__tstate);
34805 if (PyErr_Occurred()) SWIG_fail;
34806 }
34807 {
34808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34809 }
34810 return resultobj;
34811 fail:
34812 return NULL;
34813 }
34814
34815
34816 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34817 PyObject *resultobj = 0;
34818 wxWindow *arg1 = (wxWindow *) 0 ;
34819 bool result;
34820 void *argp1 = 0 ;
34821 int res1 = 0 ;
34822 PyObject *swig_obj[1] ;
34823
34824 if (!args) SWIG_fail;
34825 swig_obj[0] = args;
34826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34827 if (!SWIG_IsOK(res1)) {
34828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34829 }
34830 arg1 = reinterpret_cast< wxWindow * >(argp1);
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 result = (bool)(arg1)->TransferDataToWindow();
34834 wxPyEndAllowThreads(__tstate);
34835 if (PyErr_Occurred()) SWIG_fail;
34836 }
34837 {
34838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34839 }
34840 return resultobj;
34841 fail:
34842 return NULL;
34843 }
34844
34845
34846 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34847 PyObject *resultobj = 0;
34848 wxWindow *arg1 = (wxWindow *) 0 ;
34849 bool result;
34850 void *argp1 = 0 ;
34851 int res1 = 0 ;
34852 PyObject *swig_obj[1] ;
34853
34854 if (!args) SWIG_fail;
34855 swig_obj[0] = args;
34856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34857 if (!SWIG_IsOK(res1)) {
34858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34859 }
34860 arg1 = reinterpret_cast< wxWindow * >(argp1);
34861 {
34862 PyThreadState* __tstate = wxPyBeginAllowThreads();
34863 result = (bool)(arg1)->TransferDataFromWindow();
34864 wxPyEndAllowThreads(__tstate);
34865 if (PyErr_Occurred()) SWIG_fail;
34866 }
34867 {
34868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34869 }
34870 return resultobj;
34871 fail:
34872 return NULL;
34873 }
34874
34875
34876 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34877 PyObject *resultobj = 0;
34878 wxWindow *arg1 = (wxWindow *) 0 ;
34879 void *argp1 = 0 ;
34880 int res1 = 0 ;
34881 PyObject *swig_obj[1] ;
34882
34883 if (!args) SWIG_fail;
34884 swig_obj[0] = args;
34885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34886 if (!SWIG_IsOK(res1)) {
34887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34888 }
34889 arg1 = reinterpret_cast< wxWindow * >(argp1);
34890 {
34891 PyThreadState* __tstate = wxPyBeginAllowThreads();
34892 (arg1)->InitDialog();
34893 wxPyEndAllowThreads(__tstate);
34894 if (PyErr_Occurred()) SWIG_fail;
34895 }
34896 resultobj = SWIG_Py_Void();
34897 return resultobj;
34898 fail:
34899 return NULL;
34900 }
34901
34902
34903 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34904 PyObject *resultobj = 0;
34905 wxWindow *arg1 = (wxWindow *) 0 ;
34906 wxAcceleratorTable *arg2 = 0 ;
34907 void *argp1 = 0 ;
34908 int res1 = 0 ;
34909 void *argp2 = 0 ;
34910 int res2 = 0 ;
34911 PyObject * obj0 = 0 ;
34912 PyObject * obj1 = 0 ;
34913 char * kwnames[] = {
34914 (char *) "self",(char *) "accel", NULL
34915 };
34916
34917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34919 if (!SWIG_IsOK(res1)) {
34920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34921 }
34922 arg1 = reinterpret_cast< wxWindow * >(argp1);
34923 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34924 if (!SWIG_IsOK(res2)) {
34925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34926 }
34927 if (!argp2) {
34928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34929 }
34930 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34931 {
34932 PyThreadState* __tstate = wxPyBeginAllowThreads();
34933 (arg1)->SetAcceleratorTable((wxAcceleratorTable 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_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34945 PyObject *resultobj = 0;
34946 wxWindow *arg1 = (wxWindow *) 0 ;
34947 wxAcceleratorTable *result = 0 ;
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_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34957 }
34958 arg1 = reinterpret_cast< wxWindow * >(argp1);
34959 {
34960 PyThreadState* __tstate = wxPyBeginAllowThreads();
34961 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34962 wxPyEndAllowThreads(__tstate);
34963 if (PyErr_Occurred()) SWIG_fail;
34964 }
34965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34966 return resultobj;
34967 fail:
34968 return NULL;
34969 }
34970
34971
34972 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34973 PyObject *resultobj = 0;
34974 wxWindow *arg1 = (wxWindow *) 0 ;
34975 int arg2 ;
34976 int arg3 ;
34977 int arg4 ;
34978 bool result;
34979 void *argp1 = 0 ;
34980 int res1 = 0 ;
34981 int val2 ;
34982 int ecode2 = 0 ;
34983 int val3 ;
34984 int ecode3 = 0 ;
34985 int val4 ;
34986 int ecode4 = 0 ;
34987 PyObject * obj0 = 0 ;
34988 PyObject * obj1 = 0 ;
34989 PyObject * obj2 = 0 ;
34990 PyObject * obj3 = 0 ;
34991 char * kwnames[] = {
34992 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34993 };
34994
34995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34997 if (!SWIG_IsOK(res1)) {
34998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34999 }
35000 arg1 = reinterpret_cast< wxWindow * >(argp1);
35001 ecode2 = SWIG_AsVal_int(obj1, &val2);
35002 if (!SWIG_IsOK(ecode2)) {
35003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
35004 }
35005 arg2 = static_cast< int >(val2);
35006 ecode3 = SWIG_AsVal_int(obj2, &val3);
35007 if (!SWIG_IsOK(ecode3)) {
35008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
35009 }
35010 arg3 = static_cast< int >(val3);
35011 ecode4 = SWIG_AsVal_int(obj3, &val4);
35012 if (!SWIG_IsOK(ecode4)) {
35013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
35014 }
35015 arg4 = static_cast< int >(val4);
35016 {
35017 PyThreadState* __tstate = wxPyBeginAllowThreads();
35018 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
35019 wxPyEndAllowThreads(__tstate);
35020 if (PyErr_Occurred()) SWIG_fail;
35021 }
35022 {
35023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35024 }
35025 return resultobj;
35026 fail:
35027 return NULL;
35028 }
35029
35030
35031 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35032 PyObject *resultobj = 0;
35033 wxWindow *arg1 = (wxWindow *) 0 ;
35034 int arg2 ;
35035 bool result;
35036 void *argp1 = 0 ;
35037 int res1 = 0 ;
35038 int val2 ;
35039 int ecode2 = 0 ;
35040 PyObject * obj0 = 0 ;
35041 PyObject * obj1 = 0 ;
35042 char * kwnames[] = {
35043 (char *) "self",(char *) "hotkeyId", NULL
35044 };
35045
35046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
35047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35048 if (!SWIG_IsOK(res1)) {
35049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35050 }
35051 arg1 = reinterpret_cast< wxWindow * >(argp1);
35052 ecode2 = SWIG_AsVal_int(obj1, &val2);
35053 if (!SWIG_IsOK(ecode2)) {
35054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
35055 }
35056 arg2 = static_cast< int >(val2);
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
35060 wxPyEndAllowThreads(__tstate);
35061 if (PyErr_Occurred()) SWIG_fail;
35062 }
35063 {
35064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35065 }
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35073 PyObject *resultobj = 0;
35074 wxWindow *arg1 = (wxWindow *) 0 ;
35075 wxPoint *arg2 = 0 ;
35076 wxPoint result;
35077 void *argp1 = 0 ;
35078 int res1 = 0 ;
35079 wxPoint temp2 ;
35080 PyObject * obj0 = 0 ;
35081 PyObject * obj1 = 0 ;
35082 char * kwnames[] = {
35083 (char *) "self",(char *) "pt", NULL
35084 };
35085
35086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35088 if (!SWIG_IsOK(res1)) {
35089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35090 }
35091 arg1 = reinterpret_cast< wxWindow * >(argp1);
35092 {
35093 arg2 = &temp2;
35094 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35095 }
35096 {
35097 PyThreadState* __tstate = wxPyBeginAllowThreads();
35098 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35099 wxPyEndAllowThreads(__tstate);
35100 if (PyErr_Occurred()) SWIG_fail;
35101 }
35102 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35103 return resultobj;
35104 fail:
35105 return NULL;
35106 }
35107
35108
35109 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35110 PyObject *resultobj = 0;
35111 wxWindow *arg1 = (wxWindow *) 0 ;
35112 wxSize *arg2 = 0 ;
35113 wxSize result;
35114 void *argp1 = 0 ;
35115 int res1 = 0 ;
35116 wxSize temp2 ;
35117 PyObject * obj0 = 0 ;
35118 PyObject * obj1 = 0 ;
35119 char * kwnames[] = {
35120 (char *) "self",(char *) "sz", NULL
35121 };
35122
35123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35125 if (!SWIG_IsOK(res1)) {
35126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35127 }
35128 arg1 = reinterpret_cast< wxWindow * >(argp1);
35129 {
35130 arg2 = &temp2;
35131 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35132 }
35133 {
35134 PyThreadState* __tstate = wxPyBeginAllowThreads();
35135 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35136 wxPyEndAllowThreads(__tstate);
35137 if (PyErr_Occurred()) SWIG_fail;
35138 }
35139 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35140 return resultobj;
35141 fail:
35142 return NULL;
35143 }
35144
35145
35146 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35147 PyObject *resultobj = 0;
35148 wxWindow *arg1 = (wxWindow *) 0 ;
35149 wxPoint *arg2 = 0 ;
35150 wxPoint result;
35151 void *argp1 = 0 ;
35152 int res1 = 0 ;
35153 wxPoint temp2 ;
35154 PyObject * obj0 = 0 ;
35155 PyObject * obj1 = 0 ;
35156 char * kwnames[] = {
35157 (char *) "self",(char *) "pt", NULL
35158 };
35159
35160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35162 if (!SWIG_IsOK(res1)) {
35163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35164 }
35165 arg1 = reinterpret_cast< wxWindow * >(argp1);
35166 {
35167 arg2 = &temp2;
35168 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35169 }
35170 {
35171 PyThreadState* __tstate = wxPyBeginAllowThreads();
35172 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35173 wxPyEndAllowThreads(__tstate);
35174 if (PyErr_Occurred()) SWIG_fail;
35175 }
35176 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35177 return resultobj;
35178 fail:
35179 return NULL;
35180 }
35181
35182
35183 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35184 PyObject *resultobj = 0;
35185 wxWindow *arg1 = (wxWindow *) 0 ;
35186 wxSize *arg2 = 0 ;
35187 wxSize result;
35188 void *argp1 = 0 ;
35189 int res1 = 0 ;
35190 wxSize temp2 ;
35191 PyObject * obj0 = 0 ;
35192 PyObject * obj1 = 0 ;
35193 char * kwnames[] = {
35194 (char *) "self",(char *) "sz", NULL
35195 };
35196
35197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35199 if (!SWIG_IsOK(res1)) {
35200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35201 }
35202 arg1 = reinterpret_cast< wxWindow * >(argp1);
35203 {
35204 arg2 = &temp2;
35205 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35206 }
35207 {
35208 PyThreadState* __tstate = wxPyBeginAllowThreads();
35209 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35210 wxPyEndAllowThreads(__tstate);
35211 if (PyErr_Occurred()) SWIG_fail;
35212 }
35213 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj = 0;
35222 wxWindow *arg1 = (wxWindow *) 0 ;
35223 wxPoint *arg2 = 0 ;
35224 wxPoint result;
35225 void *argp1 = 0 ;
35226 int res1 = 0 ;
35227 wxPoint temp2 ;
35228 PyObject * obj0 = 0 ;
35229 PyObject * obj1 = 0 ;
35230 char * kwnames[] = {
35231 (char *) "self",(char *) "pt", NULL
35232 };
35233
35234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35236 if (!SWIG_IsOK(res1)) {
35237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35238 }
35239 arg1 = reinterpret_cast< wxWindow * >(argp1);
35240 {
35241 arg2 = &temp2;
35242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35243 }
35244 {
35245 PyThreadState* __tstate = wxPyBeginAllowThreads();
35246 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35258 PyObject *resultobj = 0;
35259 wxWindow *arg1 = (wxWindow *) 0 ;
35260 wxSize *arg2 = 0 ;
35261 wxSize result;
35262 void *argp1 = 0 ;
35263 int res1 = 0 ;
35264 wxSize temp2 ;
35265 PyObject * obj0 = 0 ;
35266 PyObject * obj1 = 0 ;
35267 char * kwnames[] = {
35268 (char *) "self",(char *) "sz", NULL
35269 };
35270
35271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35273 if (!SWIG_IsOK(res1)) {
35274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35275 }
35276 arg1 = reinterpret_cast< wxWindow * >(argp1);
35277 {
35278 arg2 = &temp2;
35279 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35280 }
35281 {
35282 PyThreadState* __tstate = wxPyBeginAllowThreads();
35283 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35284 wxPyEndAllowThreads(__tstate);
35285 if (PyErr_Occurred()) SWIG_fail;
35286 }
35287 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35288 return resultobj;
35289 fail:
35290 return NULL;
35291 }
35292
35293
35294 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35295 PyObject *resultobj = 0;
35296 wxWindow *arg1 = (wxWindow *) 0 ;
35297 int arg2 ;
35298 int arg3 ;
35299 void *argp1 = 0 ;
35300 int res1 = 0 ;
35301 int val2 ;
35302 int ecode2 = 0 ;
35303 int val3 ;
35304 int ecode3 = 0 ;
35305 PyObject * obj0 = 0 ;
35306 PyObject * obj1 = 0 ;
35307 PyObject * obj2 = 0 ;
35308 char * kwnames[] = {
35309 (char *) "self",(char *) "x",(char *) "y", NULL
35310 };
35311
35312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35314 if (!SWIG_IsOK(res1)) {
35315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35316 }
35317 arg1 = reinterpret_cast< wxWindow * >(argp1);
35318 ecode2 = SWIG_AsVal_int(obj1, &val2);
35319 if (!SWIG_IsOK(ecode2)) {
35320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35321 }
35322 arg2 = static_cast< int >(val2);
35323 ecode3 = SWIG_AsVal_int(obj2, &val3);
35324 if (!SWIG_IsOK(ecode3)) {
35325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35326 }
35327 arg3 = static_cast< int >(val3);
35328 {
35329 PyThreadState* __tstate = wxPyBeginAllowThreads();
35330 (arg1)->WarpPointer(arg2,arg3);
35331 wxPyEndAllowThreads(__tstate);
35332 if (PyErr_Occurred()) SWIG_fail;
35333 }
35334 resultobj = SWIG_Py_Void();
35335 return resultobj;
35336 fail:
35337 return NULL;
35338 }
35339
35340
35341 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35342 PyObject *resultobj = 0;
35343 wxWindow *arg1 = (wxWindow *) 0 ;
35344 void *argp1 = 0 ;
35345 int res1 = 0 ;
35346 PyObject *swig_obj[1] ;
35347
35348 if (!args) SWIG_fail;
35349 swig_obj[0] = args;
35350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35351 if (!SWIG_IsOK(res1)) {
35352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35353 }
35354 arg1 = reinterpret_cast< wxWindow * >(argp1);
35355 {
35356 PyThreadState* __tstate = wxPyBeginAllowThreads();
35357 (arg1)->CaptureMouse();
35358 wxPyEndAllowThreads(__tstate);
35359 if (PyErr_Occurred()) SWIG_fail;
35360 }
35361 resultobj = SWIG_Py_Void();
35362 return resultobj;
35363 fail:
35364 return NULL;
35365 }
35366
35367
35368 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35369 PyObject *resultobj = 0;
35370 wxWindow *arg1 = (wxWindow *) 0 ;
35371 void *argp1 = 0 ;
35372 int res1 = 0 ;
35373 PyObject *swig_obj[1] ;
35374
35375 if (!args) SWIG_fail;
35376 swig_obj[0] = args;
35377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35378 if (!SWIG_IsOK(res1)) {
35379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35380 }
35381 arg1 = reinterpret_cast< wxWindow * >(argp1);
35382 {
35383 PyThreadState* __tstate = wxPyBeginAllowThreads();
35384 (arg1)->ReleaseMouse();
35385 wxPyEndAllowThreads(__tstate);
35386 if (PyErr_Occurred()) SWIG_fail;
35387 }
35388 resultobj = SWIG_Py_Void();
35389 return resultobj;
35390 fail:
35391 return NULL;
35392 }
35393
35394
35395 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35396 PyObject *resultobj = 0;
35397 wxWindow *result = 0 ;
35398
35399 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35400 {
35401 if (!wxPyCheckForApp()) SWIG_fail;
35402 PyThreadState* __tstate = wxPyBeginAllowThreads();
35403 result = (wxWindow *)wxWindow::GetCapture();
35404 wxPyEndAllowThreads(__tstate);
35405 if (PyErr_Occurred()) SWIG_fail;
35406 }
35407 {
35408 resultobj = wxPyMake_wxObject(result, 0);
35409 }
35410 return resultobj;
35411 fail:
35412 return NULL;
35413 }
35414
35415
35416 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35417 PyObject *resultobj = 0;
35418 wxWindow *arg1 = (wxWindow *) 0 ;
35419 bool result;
35420 void *argp1 = 0 ;
35421 int res1 = 0 ;
35422 PyObject *swig_obj[1] ;
35423
35424 if (!args) SWIG_fail;
35425 swig_obj[0] = args;
35426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35427 if (!SWIG_IsOK(res1)) {
35428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35429 }
35430 arg1 = reinterpret_cast< wxWindow * >(argp1);
35431 {
35432 PyThreadState* __tstate = wxPyBeginAllowThreads();
35433 result = (bool)((wxWindow const *)arg1)->HasCapture();
35434 wxPyEndAllowThreads(__tstate);
35435 if (PyErr_Occurred()) SWIG_fail;
35436 }
35437 {
35438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35439 }
35440 return resultobj;
35441 fail:
35442 return NULL;
35443 }
35444
35445
35446 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35447 PyObject *resultobj = 0;
35448 wxWindow *arg1 = (wxWindow *) 0 ;
35449 bool arg2 = (bool) true ;
35450 wxRect *arg3 = (wxRect *) NULL ;
35451 void *argp1 = 0 ;
35452 int res1 = 0 ;
35453 bool val2 ;
35454 int ecode2 = 0 ;
35455 void *argp3 = 0 ;
35456 int res3 = 0 ;
35457 PyObject * obj0 = 0 ;
35458 PyObject * obj1 = 0 ;
35459 PyObject * obj2 = 0 ;
35460 char * kwnames[] = {
35461 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35462 };
35463
35464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35466 if (!SWIG_IsOK(res1)) {
35467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35468 }
35469 arg1 = reinterpret_cast< wxWindow * >(argp1);
35470 if (obj1) {
35471 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35472 if (!SWIG_IsOK(ecode2)) {
35473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35474 }
35475 arg2 = static_cast< bool >(val2);
35476 }
35477 if (obj2) {
35478 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35479 if (!SWIG_IsOK(res3)) {
35480 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35481 }
35482 arg3 = reinterpret_cast< wxRect * >(argp3);
35483 }
35484 {
35485 PyThreadState* __tstate = wxPyBeginAllowThreads();
35486 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35487 wxPyEndAllowThreads(__tstate);
35488 if (PyErr_Occurred()) SWIG_fail;
35489 }
35490 resultobj = SWIG_Py_Void();
35491 return resultobj;
35492 fail:
35493 return NULL;
35494 }
35495
35496
35497 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35498 PyObject *resultobj = 0;
35499 wxWindow *arg1 = (wxWindow *) 0 ;
35500 wxRect *arg2 = 0 ;
35501 bool arg3 = (bool) true ;
35502 void *argp1 = 0 ;
35503 int res1 = 0 ;
35504 wxRect temp2 ;
35505 bool val3 ;
35506 int ecode3 = 0 ;
35507 PyObject * obj0 = 0 ;
35508 PyObject * obj1 = 0 ;
35509 PyObject * obj2 = 0 ;
35510 char * kwnames[] = {
35511 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35512 };
35513
35514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35516 if (!SWIG_IsOK(res1)) {
35517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35518 }
35519 arg1 = reinterpret_cast< wxWindow * >(argp1);
35520 {
35521 arg2 = &temp2;
35522 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35523 }
35524 if (obj2) {
35525 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35526 if (!SWIG_IsOK(ecode3)) {
35527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35528 }
35529 arg3 = static_cast< bool >(val3);
35530 }
35531 {
35532 PyThreadState* __tstate = wxPyBeginAllowThreads();
35533 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35534 wxPyEndAllowThreads(__tstate);
35535 if (PyErr_Occurred()) SWIG_fail;
35536 }
35537 resultobj = SWIG_Py_Void();
35538 return resultobj;
35539 fail:
35540 return NULL;
35541 }
35542
35543
35544 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35545 PyObject *resultobj = 0;
35546 wxWindow *arg1 = (wxWindow *) 0 ;
35547 void *argp1 = 0 ;
35548 int res1 = 0 ;
35549 PyObject *swig_obj[1] ;
35550
35551 if (!args) SWIG_fail;
35552 swig_obj[0] = args;
35553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35554 if (!SWIG_IsOK(res1)) {
35555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35556 }
35557 arg1 = reinterpret_cast< wxWindow * >(argp1);
35558 {
35559 PyThreadState* __tstate = wxPyBeginAllowThreads();
35560 (arg1)->Update();
35561 wxPyEndAllowThreads(__tstate);
35562 if (PyErr_Occurred()) SWIG_fail;
35563 }
35564 resultobj = SWIG_Py_Void();
35565 return resultobj;
35566 fail:
35567 return NULL;
35568 }
35569
35570
35571 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35572 PyObject *resultobj = 0;
35573 wxWindow *arg1 = (wxWindow *) 0 ;
35574 void *argp1 = 0 ;
35575 int res1 = 0 ;
35576 PyObject *swig_obj[1] ;
35577
35578 if (!args) SWIG_fail;
35579 swig_obj[0] = args;
35580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35581 if (!SWIG_IsOK(res1)) {
35582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35583 }
35584 arg1 = reinterpret_cast< wxWindow * >(argp1);
35585 {
35586 PyThreadState* __tstate = wxPyBeginAllowThreads();
35587 (arg1)->ClearBackground();
35588 wxPyEndAllowThreads(__tstate);
35589 if (PyErr_Occurred()) SWIG_fail;
35590 }
35591 resultobj = SWIG_Py_Void();
35592 return resultobj;
35593 fail:
35594 return NULL;
35595 }
35596
35597
35598 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35599 PyObject *resultobj = 0;
35600 wxWindow *arg1 = (wxWindow *) 0 ;
35601 void *argp1 = 0 ;
35602 int res1 = 0 ;
35603 PyObject *swig_obj[1] ;
35604
35605 if (!args) SWIG_fail;
35606 swig_obj[0] = args;
35607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35608 if (!SWIG_IsOK(res1)) {
35609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35610 }
35611 arg1 = reinterpret_cast< wxWindow * >(argp1);
35612 {
35613 PyThreadState* __tstate = wxPyBeginAllowThreads();
35614 (arg1)->Freeze();
35615 wxPyEndAllowThreads(__tstate);
35616 if (PyErr_Occurred()) SWIG_fail;
35617 }
35618 resultobj = SWIG_Py_Void();
35619 return resultobj;
35620 fail:
35621 return NULL;
35622 }
35623
35624
35625 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35626 PyObject *resultobj = 0;
35627 wxWindow *arg1 = (wxWindow *) 0 ;
35628 bool result;
35629 void *argp1 = 0 ;
35630 int res1 = 0 ;
35631 PyObject *swig_obj[1] ;
35632
35633 if (!args) SWIG_fail;
35634 swig_obj[0] = args;
35635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35636 if (!SWIG_IsOK(res1)) {
35637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35638 }
35639 arg1 = reinterpret_cast< wxWindow * >(argp1);
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35643 wxPyEndAllowThreads(__tstate);
35644 if (PyErr_Occurred()) SWIG_fail;
35645 }
35646 {
35647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35648 }
35649 return resultobj;
35650 fail:
35651 return NULL;
35652 }
35653
35654
35655 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35656 PyObject *resultobj = 0;
35657 wxWindow *arg1 = (wxWindow *) 0 ;
35658 void *argp1 = 0 ;
35659 int res1 = 0 ;
35660 PyObject *swig_obj[1] ;
35661
35662 if (!args) SWIG_fail;
35663 swig_obj[0] = args;
35664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35665 if (!SWIG_IsOK(res1)) {
35666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35667 }
35668 arg1 = reinterpret_cast< wxWindow * >(argp1);
35669 {
35670 PyThreadState* __tstate = wxPyBeginAllowThreads();
35671 (arg1)->Thaw();
35672 wxPyEndAllowThreads(__tstate);
35673 if (PyErr_Occurred()) SWIG_fail;
35674 }
35675 resultobj = SWIG_Py_Void();
35676 return resultobj;
35677 fail:
35678 return NULL;
35679 }
35680
35681
35682 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35683 PyObject *resultobj = 0;
35684 wxWindow *arg1 = (wxWindow *) 0 ;
35685 wxDC *arg2 = 0 ;
35686 void *argp1 = 0 ;
35687 int res1 = 0 ;
35688 void *argp2 = 0 ;
35689 int res2 = 0 ;
35690 PyObject * obj0 = 0 ;
35691 PyObject * obj1 = 0 ;
35692 char * kwnames[] = {
35693 (char *) "self",(char *) "dc", NULL
35694 };
35695
35696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35698 if (!SWIG_IsOK(res1)) {
35699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35700 }
35701 arg1 = reinterpret_cast< wxWindow * >(argp1);
35702 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35703 if (!SWIG_IsOK(res2)) {
35704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35705 }
35706 if (!argp2) {
35707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35708 }
35709 arg2 = reinterpret_cast< wxDC * >(argp2);
35710 {
35711 PyThreadState* __tstate = wxPyBeginAllowThreads();
35712 (arg1)->PrepareDC(*arg2);
35713 wxPyEndAllowThreads(__tstate);
35714 if (PyErr_Occurred()) SWIG_fail;
35715 }
35716 resultobj = SWIG_Py_Void();
35717 return resultobj;
35718 fail:
35719 return NULL;
35720 }
35721
35722
35723 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35724 PyObject *resultobj = 0;
35725 wxWindow *arg1 = (wxWindow *) 0 ;
35726 bool result;
35727 void *argp1 = 0 ;
35728 int res1 = 0 ;
35729 PyObject *swig_obj[1] ;
35730
35731 if (!args) SWIG_fail;
35732 swig_obj[0] = args;
35733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35734 if (!SWIG_IsOK(res1)) {
35735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
35736 }
35737 arg1 = reinterpret_cast< wxWindow * >(argp1);
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 {
35745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35746 }
35747 return resultobj;
35748 fail:
35749 return NULL;
35750 }
35751
35752
35753 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35754 PyObject *resultobj = 0;
35755 wxWindow *arg1 = (wxWindow *) 0 ;
35756 wxRegion *result = 0 ;
35757 void *argp1 = 0 ;
35758 int res1 = 0 ;
35759 PyObject *swig_obj[1] ;
35760
35761 if (!args) SWIG_fail;
35762 swig_obj[0] = args;
35763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35764 if (!SWIG_IsOK(res1)) {
35765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35766 }
35767 arg1 = reinterpret_cast< wxWindow * >(argp1);
35768 {
35769 PyThreadState* __tstate = wxPyBeginAllowThreads();
35770 {
35771 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35772 result = (wxRegion *) &_result_ref;
35773 }
35774 wxPyEndAllowThreads(__tstate);
35775 if (PyErr_Occurred()) SWIG_fail;
35776 }
35777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35778 return resultobj;
35779 fail:
35780 return NULL;
35781 }
35782
35783
35784 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35785 PyObject *resultobj = 0;
35786 wxWindow *arg1 = (wxWindow *) 0 ;
35787 wxRect result;
35788 void *argp1 = 0 ;
35789 int res1 = 0 ;
35790 PyObject *swig_obj[1] ;
35791
35792 if (!args) SWIG_fail;
35793 swig_obj[0] = args;
35794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35795 if (!SWIG_IsOK(res1)) {
35796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35797 }
35798 arg1 = reinterpret_cast< wxWindow * >(argp1);
35799 {
35800 PyThreadState* __tstate = wxPyBeginAllowThreads();
35801 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35806 return resultobj;
35807 fail:
35808 return NULL;
35809 }
35810
35811
35812 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35813 PyObject *resultobj = 0;
35814 wxWindow *arg1 = (wxWindow *) 0 ;
35815 int arg2 ;
35816 int arg3 ;
35817 int arg4 = (int) 1 ;
35818 int arg5 = (int) 1 ;
35819 bool result;
35820 void *argp1 = 0 ;
35821 int res1 = 0 ;
35822 int val2 ;
35823 int ecode2 = 0 ;
35824 int val3 ;
35825 int ecode3 = 0 ;
35826 int val4 ;
35827 int ecode4 = 0 ;
35828 int val5 ;
35829 int ecode5 = 0 ;
35830 PyObject * obj0 = 0 ;
35831 PyObject * obj1 = 0 ;
35832 PyObject * obj2 = 0 ;
35833 PyObject * obj3 = 0 ;
35834 PyObject * obj4 = 0 ;
35835 char * kwnames[] = {
35836 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35837 };
35838
35839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35843 }
35844 arg1 = reinterpret_cast< wxWindow * >(argp1);
35845 ecode2 = SWIG_AsVal_int(obj1, &val2);
35846 if (!SWIG_IsOK(ecode2)) {
35847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35848 }
35849 arg2 = static_cast< int >(val2);
35850 ecode3 = SWIG_AsVal_int(obj2, &val3);
35851 if (!SWIG_IsOK(ecode3)) {
35852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35853 }
35854 arg3 = static_cast< int >(val3);
35855 if (obj3) {
35856 ecode4 = SWIG_AsVal_int(obj3, &val4);
35857 if (!SWIG_IsOK(ecode4)) {
35858 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35859 }
35860 arg4 = static_cast< int >(val4);
35861 }
35862 if (obj4) {
35863 ecode5 = SWIG_AsVal_int(obj4, &val5);
35864 if (!SWIG_IsOK(ecode5)) {
35865 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35866 }
35867 arg5 = static_cast< int >(val5);
35868 }
35869 {
35870 PyThreadState* __tstate = wxPyBeginAllowThreads();
35871 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35872 wxPyEndAllowThreads(__tstate);
35873 if (PyErr_Occurred()) SWIG_fail;
35874 }
35875 {
35876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35877 }
35878 return resultobj;
35879 fail:
35880 return NULL;
35881 }
35882
35883
35884 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35885 PyObject *resultobj = 0;
35886 wxWindow *arg1 = (wxWindow *) 0 ;
35887 wxPoint *arg2 = 0 ;
35888 bool result;
35889 void *argp1 = 0 ;
35890 int res1 = 0 ;
35891 wxPoint temp2 ;
35892 PyObject * obj0 = 0 ;
35893 PyObject * obj1 = 0 ;
35894 char * kwnames[] = {
35895 (char *) "self",(char *) "pt", NULL
35896 };
35897
35898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35900 if (!SWIG_IsOK(res1)) {
35901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35902 }
35903 arg1 = reinterpret_cast< wxWindow * >(argp1);
35904 {
35905 arg2 = &temp2;
35906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35907 }
35908 {
35909 PyThreadState* __tstate = wxPyBeginAllowThreads();
35910 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35911 wxPyEndAllowThreads(__tstate);
35912 if (PyErr_Occurred()) SWIG_fail;
35913 }
35914 {
35915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35916 }
35917 return resultobj;
35918 fail:
35919 return NULL;
35920 }
35921
35922
35923 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35924 PyObject *resultobj = 0;
35925 wxWindow *arg1 = (wxWindow *) 0 ;
35926 wxRect *arg2 = 0 ;
35927 bool result;
35928 void *argp1 = 0 ;
35929 int res1 = 0 ;
35930 wxRect temp2 ;
35931 PyObject * obj0 = 0 ;
35932 PyObject * obj1 = 0 ;
35933 char * kwnames[] = {
35934 (char *) "self",(char *) "rect", NULL
35935 };
35936
35937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35939 if (!SWIG_IsOK(res1)) {
35940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35941 }
35942 arg1 = reinterpret_cast< wxWindow * >(argp1);
35943 {
35944 arg2 = &temp2;
35945 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35946 }
35947 {
35948 PyThreadState* __tstate = wxPyBeginAllowThreads();
35949 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35950 wxPyEndAllowThreads(__tstate);
35951 if (PyErr_Occurred()) SWIG_fail;
35952 }
35953 {
35954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35955 }
35956 return resultobj;
35957 fail:
35958 return NULL;
35959 }
35960
35961
35962 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35963 PyObject *resultobj = 0;
35964 wxWindow *arg1 = (wxWindow *) 0 ;
35965 SwigValueWrapper<wxVisualAttributes > result;
35966 void *argp1 = 0 ;
35967 int res1 = 0 ;
35968 PyObject *swig_obj[1] ;
35969
35970 if (!args) SWIG_fail;
35971 swig_obj[0] = args;
35972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35973 if (!SWIG_IsOK(res1)) {
35974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35975 }
35976 arg1 = reinterpret_cast< wxWindow * >(argp1);
35977 {
35978 PyThreadState* __tstate = wxPyBeginAllowThreads();
35979 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35980 wxPyEndAllowThreads(__tstate);
35981 if (PyErr_Occurred()) SWIG_fail;
35982 }
35983 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35984 return resultobj;
35985 fail:
35986 return NULL;
35987 }
35988
35989
35990 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35991 PyObject *resultobj = 0;
35992 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35993 SwigValueWrapper<wxVisualAttributes > result;
35994 int val1 ;
35995 int ecode1 = 0 ;
35996 PyObject * obj0 = 0 ;
35997 char * kwnames[] = {
35998 (char *) "variant", NULL
35999 };
36000
36001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
36002 if (obj0) {
36003 ecode1 = SWIG_AsVal_int(obj0, &val1);
36004 if (!SWIG_IsOK(ecode1)) {
36005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
36006 }
36007 arg1 = static_cast< wxWindowVariant >(val1);
36008 }
36009 {
36010 if (!wxPyCheckForApp()) SWIG_fail;
36011 PyThreadState* __tstate = wxPyBeginAllowThreads();
36012 result = wxWindow::GetClassDefaultAttributes(arg1);
36013 wxPyEndAllowThreads(__tstate);
36014 if (PyErr_Occurred()) SWIG_fail;
36015 }
36016 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36017 return resultobj;
36018 fail:
36019 return NULL;
36020 }
36021
36022
36023 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36024 PyObject *resultobj = 0;
36025 wxWindow *arg1 = (wxWindow *) 0 ;
36026 wxColour *arg2 = 0 ;
36027 bool result;
36028 void *argp1 = 0 ;
36029 int res1 = 0 ;
36030 wxColour temp2 ;
36031 PyObject * obj0 = 0 ;
36032 PyObject * obj1 = 0 ;
36033 char * kwnames[] = {
36034 (char *) "self",(char *) "colour", NULL
36035 };
36036
36037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36039 if (!SWIG_IsOK(res1)) {
36040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36041 }
36042 arg1 = reinterpret_cast< wxWindow * >(argp1);
36043 {
36044 arg2 = &temp2;
36045 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36046 }
36047 {
36048 PyThreadState* __tstate = wxPyBeginAllowThreads();
36049 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
36050 wxPyEndAllowThreads(__tstate);
36051 if (PyErr_Occurred()) SWIG_fail;
36052 }
36053 {
36054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36055 }
36056 return resultobj;
36057 fail:
36058 return NULL;
36059 }
36060
36061
36062 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36063 PyObject *resultobj = 0;
36064 wxWindow *arg1 = (wxWindow *) 0 ;
36065 wxColour *arg2 = 0 ;
36066 void *argp1 = 0 ;
36067 int res1 = 0 ;
36068 wxColour temp2 ;
36069 PyObject * obj0 = 0 ;
36070 PyObject * obj1 = 0 ;
36071 char * kwnames[] = {
36072 (char *) "self",(char *) "colour", NULL
36073 };
36074
36075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36077 if (!SWIG_IsOK(res1)) {
36078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36079 }
36080 arg1 = reinterpret_cast< wxWindow * >(argp1);
36081 {
36082 arg2 = &temp2;
36083 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36084 }
36085 {
36086 PyThreadState* __tstate = wxPyBeginAllowThreads();
36087 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
36088 wxPyEndAllowThreads(__tstate);
36089 if (PyErr_Occurred()) SWIG_fail;
36090 }
36091 resultobj = SWIG_Py_Void();
36092 return resultobj;
36093 fail:
36094 return NULL;
36095 }
36096
36097
36098 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36099 PyObject *resultobj = 0;
36100 wxWindow *arg1 = (wxWindow *) 0 ;
36101 wxColour *arg2 = 0 ;
36102 bool result;
36103 void *argp1 = 0 ;
36104 int res1 = 0 ;
36105 wxColour temp2 ;
36106 PyObject * obj0 = 0 ;
36107 PyObject * obj1 = 0 ;
36108 char * kwnames[] = {
36109 (char *) "self",(char *) "colour", NULL
36110 };
36111
36112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36114 if (!SWIG_IsOK(res1)) {
36115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36116 }
36117 arg1 = reinterpret_cast< wxWindow * >(argp1);
36118 {
36119 arg2 = &temp2;
36120 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36121 }
36122 {
36123 PyThreadState* __tstate = wxPyBeginAllowThreads();
36124 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
36125 wxPyEndAllowThreads(__tstate);
36126 if (PyErr_Occurred()) SWIG_fail;
36127 }
36128 {
36129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36130 }
36131 return resultobj;
36132 fail:
36133 return NULL;
36134 }
36135
36136
36137 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36138 PyObject *resultobj = 0;
36139 wxWindow *arg1 = (wxWindow *) 0 ;
36140 wxColour *arg2 = 0 ;
36141 void *argp1 = 0 ;
36142 int res1 = 0 ;
36143 wxColour temp2 ;
36144 PyObject * obj0 = 0 ;
36145 PyObject * obj1 = 0 ;
36146 char * kwnames[] = {
36147 (char *) "self",(char *) "colour", NULL
36148 };
36149
36150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36152 if (!SWIG_IsOK(res1)) {
36153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36154 }
36155 arg1 = reinterpret_cast< wxWindow * >(argp1);
36156 {
36157 arg2 = &temp2;
36158 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36159 }
36160 {
36161 PyThreadState* __tstate = wxPyBeginAllowThreads();
36162 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36163 wxPyEndAllowThreads(__tstate);
36164 if (PyErr_Occurred()) SWIG_fail;
36165 }
36166 resultobj = SWIG_Py_Void();
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36174 PyObject *resultobj = 0;
36175 wxWindow *arg1 = (wxWindow *) 0 ;
36176 wxColour result;
36177 void *argp1 = 0 ;
36178 int res1 = 0 ;
36179 PyObject *swig_obj[1] ;
36180
36181 if (!args) SWIG_fail;
36182 swig_obj[0] = args;
36183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36184 if (!SWIG_IsOK(res1)) {
36185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36186 }
36187 arg1 = reinterpret_cast< wxWindow * >(argp1);
36188 {
36189 PyThreadState* __tstate = wxPyBeginAllowThreads();
36190 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36191 wxPyEndAllowThreads(__tstate);
36192 if (PyErr_Occurred()) SWIG_fail;
36193 }
36194 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36195 return resultobj;
36196 fail:
36197 return NULL;
36198 }
36199
36200
36201 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36202 PyObject *resultobj = 0;
36203 wxWindow *arg1 = (wxWindow *) 0 ;
36204 wxColour result;
36205 void *argp1 = 0 ;
36206 int res1 = 0 ;
36207 PyObject *swig_obj[1] ;
36208
36209 if (!args) SWIG_fail;
36210 swig_obj[0] = args;
36211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36212 if (!SWIG_IsOK(res1)) {
36213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36214 }
36215 arg1 = reinterpret_cast< wxWindow * >(argp1);
36216 {
36217 PyThreadState* __tstate = wxPyBeginAllowThreads();
36218 result = ((wxWindow const *)arg1)->GetForegroundColour();
36219 wxPyEndAllowThreads(__tstate);
36220 if (PyErr_Occurred()) SWIG_fail;
36221 }
36222 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36223 return resultobj;
36224 fail:
36225 return NULL;
36226 }
36227
36228
36229 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36230 PyObject *resultobj = 0;
36231 wxWindow *arg1 = (wxWindow *) 0 ;
36232 bool result;
36233 void *argp1 = 0 ;
36234 int res1 = 0 ;
36235 PyObject *swig_obj[1] ;
36236
36237 if (!args) SWIG_fail;
36238 swig_obj[0] = args;
36239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36240 if (!SWIG_IsOK(res1)) {
36241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36242 }
36243 arg1 = reinterpret_cast< wxWindow * >(argp1);
36244 {
36245 PyThreadState* __tstate = wxPyBeginAllowThreads();
36246 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36247 wxPyEndAllowThreads(__tstate);
36248 if (PyErr_Occurred()) SWIG_fail;
36249 }
36250 {
36251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36252 }
36253 return resultobj;
36254 fail:
36255 return NULL;
36256 }
36257
36258
36259 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36260 PyObject *resultobj = 0;
36261 wxWindow *arg1 = (wxWindow *) 0 ;
36262 bool result;
36263 void *argp1 = 0 ;
36264 int res1 = 0 ;
36265 PyObject *swig_obj[1] ;
36266
36267 if (!args) SWIG_fail;
36268 swig_obj[0] = args;
36269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36270 if (!SWIG_IsOK(res1)) {
36271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36272 }
36273 arg1 = reinterpret_cast< wxWindow * >(argp1);
36274 {
36275 PyThreadState* __tstate = wxPyBeginAllowThreads();
36276 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36277 wxPyEndAllowThreads(__tstate);
36278 if (PyErr_Occurred()) SWIG_fail;
36279 }
36280 {
36281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36282 }
36283 return resultobj;
36284 fail:
36285 return NULL;
36286 }
36287
36288
36289 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36290 PyObject *resultobj = 0;
36291 wxWindow *arg1 = (wxWindow *) 0 ;
36292 wxBackgroundStyle 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 *) "style", NULL
36302 };
36303
36304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",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_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
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_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36313 }
36314 arg2 = static_cast< wxBackgroundStyle >(val2);
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = (bool)(arg1)->SetBackgroundStyle(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_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36331 PyObject *resultobj = 0;
36332 wxWindow *arg1 = (wxWindow *) 0 ;
36333 wxBackgroundStyle result;
36334 void *argp1 = 0 ;
36335 int res1 = 0 ;
36336 PyObject *swig_obj[1] ;
36337
36338 if (!args) SWIG_fail;
36339 swig_obj[0] = args;
36340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36341 if (!SWIG_IsOK(res1)) {
36342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36343 }
36344 arg1 = reinterpret_cast< wxWindow * >(argp1);
36345 {
36346 PyThreadState* __tstate = wxPyBeginAllowThreads();
36347 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36348 wxPyEndAllowThreads(__tstate);
36349 if (PyErr_Occurred()) SWIG_fail;
36350 }
36351 resultobj = SWIG_From_int(static_cast< int >(result));
36352 return resultobj;
36353 fail:
36354 return NULL;
36355 }
36356
36357
36358 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36359 PyObject *resultobj = 0;
36360 wxWindow *arg1 = (wxWindow *) 0 ;
36361 bool result;
36362 void *argp1 = 0 ;
36363 int res1 = 0 ;
36364 PyObject *swig_obj[1] ;
36365
36366 if (!args) SWIG_fail;
36367 swig_obj[0] = args;
36368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36369 if (!SWIG_IsOK(res1)) {
36370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36371 }
36372 arg1 = reinterpret_cast< wxWindow * >(argp1);
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 result = (bool)(arg1)->HasTransparentBackground();
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 {
36380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36381 }
36382 return resultobj;
36383 fail:
36384 return NULL;
36385 }
36386
36387
36388 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36389 PyObject *resultobj = 0;
36390 wxWindow *arg1 = (wxWindow *) 0 ;
36391 wxCursor *arg2 = 0 ;
36392 bool result;
36393 void *argp1 = 0 ;
36394 int res1 = 0 ;
36395 void *argp2 = 0 ;
36396 int res2 = 0 ;
36397 PyObject * obj0 = 0 ;
36398 PyObject * obj1 = 0 ;
36399 char * kwnames[] = {
36400 (char *) "self",(char *) "cursor", NULL
36401 };
36402
36403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36405 if (!SWIG_IsOK(res1)) {
36406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36407 }
36408 arg1 = reinterpret_cast< wxWindow * >(argp1);
36409 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36410 if (!SWIG_IsOK(res2)) {
36411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36412 }
36413 if (!argp2) {
36414 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36415 }
36416 arg2 = reinterpret_cast< wxCursor * >(argp2);
36417 {
36418 PyThreadState* __tstate = wxPyBeginAllowThreads();
36419 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36420 wxPyEndAllowThreads(__tstate);
36421 if (PyErr_Occurred()) SWIG_fail;
36422 }
36423 {
36424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36425 }
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36433 PyObject *resultobj = 0;
36434 wxWindow *arg1 = (wxWindow *) 0 ;
36435 wxCursor result;
36436 void *argp1 = 0 ;
36437 int res1 = 0 ;
36438 PyObject *swig_obj[1] ;
36439
36440 if (!args) SWIG_fail;
36441 swig_obj[0] = args;
36442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36443 if (!SWIG_IsOK(res1)) {
36444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36445 }
36446 arg1 = reinterpret_cast< wxWindow * >(argp1);
36447 {
36448 PyThreadState* __tstate = wxPyBeginAllowThreads();
36449 result = (arg1)->GetCursor();
36450 wxPyEndAllowThreads(__tstate);
36451 if (PyErr_Occurred()) SWIG_fail;
36452 }
36453 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36454 return resultobj;
36455 fail:
36456 return NULL;
36457 }
36458
36459
36460 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36461 PyObject *resultobj = 0;
36462 wxWindow *arg1 = (wxWindow *) 0 ;
36463 wxFont *arg2 = 0 ;
36464 bool result;
36465 void *argp1 = 0 ;
36466 int res1 = 0 ;
36467 void *argp2 = 0 ;
36468 int res2 = 0 ;
36469 PyObject * obj0 = 0 ;
36470 PyObject * obj1 = 0 ;
36471 char * kwnames[] = {
36472 (char *) "self",(char *) "font", NULL
36473 };
36474
36475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36477 if (!SWIG_IsOK(res1)) {
36478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36479 }
36480 arg1 = reinterpret_cast< wxWindow * >(argp1);
36481 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36482 if (!SWIG_IsOK(res2)) {
36483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36484 }
36485 if (!argp2) {
36486 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36487 }
36488 arg2 = reinterpret_cast< wxFont * >(argp2);
36489 {
36490 PyThreadState* __tstate = wxPyBeginAllowThreads();
36491 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36492 wxPyEndAllowThreads(__tstate);
36493 if (PyErr_Occurred()) SWIG_fail;
36494 }
36495 {
36496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36497 }
36498 return resultobj;
36499 fail:
36500 return NULL;
36501 }
36502
36503
36504 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36505 PyObject *resultobj = 0;
36506 wxWindow *arg1 = (wxWindow *) 0 ;
36507 wxFont *arg2 = 0 ;
36508 void *argp1 = 0 ;
36509 int res1 = 0 ;
36510 void *argp2 = 0 ;
36511 int res2 = 0 ;
36512 PyObject * obj0 = 0 ;
36513 PyObject * obj1 = 0 ;
36514 char * kwnames[] = {
36515 (char *) "self",(char *) "font", NULL
36516 };
36517
36518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",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_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36522 }
36523 arg1 = reinterpret_cast< wxWindow * >(argp1);
36524 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36525 if (!SWIG_IsOK(res2)) {
36526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36527 }
36528 if (!argp2) {
36529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36530 }
36531 arg2 = reinterpret_cast< wxFont * >(argp2);
36532 {
36533 PyThreadState* __tstate = wxPyBeginAllowThreads();
36534 (arg1)->SetOwnFont((wxFont const &)*arg2);
36535 wxPyEndAllowThreads(__tstate);
36536 if (PyErr_Occurred()) SWIG_fail;
36537 }
36538 resultobj = SWIG_Py_Void();
36539 return resultobj;
36540 fail:
36541 return NULL;
36542 }
36543
36544
36545 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36546 PyObject *resultobj = 0;
36547 wxWindow *arg1 = (wxWindow *) 0 ;
36548 wxFont result;
36549 void *argp1 = 0 ;
36550 int res1 = 0 ;
36551 PyObject *swig_obj[1] ;
36552
36553 if (!args) SWIG_fail;
36554 swig_obj[0] = args;
36555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36556 if (!SWIG_IsOK(res1)) {
36557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36558 }
36559 arg1 = reinterpret_cast< wxWindow * >(argp1);
36560 {
36561 PyThreadState* __tstate = wxPyBeginAllowThreads();
36562 result = (arg1)->GetFont();
36563 wxPyEndAllowThreads(__tstate);
36564 if (PyErr_Occurred()) SWIG_fail;
36565 }
36566 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36567 return resultobj;
36568 fail:
36569 return NULL;
36570 }
36571
36572
36573 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36574 PyObject *resultobj = 0;
36575 wxWindow *arg1 = (wxWindow *) 0 ;
36576 wxCaret *arg2 = (wxCaret *) 0 ;
36577 void *argp1 = 0 ;
36578 int res1 = 0 ;
36579 int res2 = 0 ;
36580 PyObject * obj0 = 0 ;
36581 PyObject * obj1 = 0 ;
36582 char * kwnames[] = {
36583 (char *) "self",(char *) "caret", NULL
36584 };
36585
36586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36588 if (!SWIG_IsOK(res1)) {
36589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36590 }
36591 arg1 = reinterpret_cast< wxWindow * >(argp1);
36592 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36593 if (!SWIG_IsOK(res2)) {
36594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36595 }
36596 {
36597 PyThreadState* __tstate = wxPyBeginAllowThreads();
36598 (arg1)->SetCaret(arg2);
36599 wxPyEndAllowThreads(__tstate);
36600 if (PyErr_Occurred()) SWIG_fail;
36601 }
36602 resultobj = SWIG_Py_Void();
36603 return resultobj;
36604 fail:
36605 return NULL;
36606 }
36607
36608
36609 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36610 PyObject *resultobj = 0;
36611 wxWindow *arg1 = (wxWindow *) 0 ;
36612 wxCaret *result = 0 ;
36613 void *argp1 = 0 ;
36614 int res1 = 0 ;
36615 PyObject *swig_obj[1] ;
36616
36617 if (!args) SWIG_fail;
36618 swig_obj[0] = args;
36619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36620 if (!SWIG_IsOK(res1)) {
36621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36622 }
36623 arg1 = reinterpret_cast< wxWindow * >(argp1);
36624 {
36625 PyThreadState* __tstate = wxPyBeginAllowThreads();
36626 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36631 return resultobj;
36632 fail:
36633 return NULL;
36634 }
36635
36636
36637 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36638 PyObject *resultobj = 0;
36639 wxWindow *arg1 = (wxWindow *) 0 ;
36640 int result;
36641 void *argp1 = 0 ;
36642 int res1 = 0 ;
36643 PyObject *swig_obj[1] ;
36644
36645 if (!args) SWIG_fail;
36646 swig_obj[0] = args;
36647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36648 if (!SWIG_IsOK(res1)) {
36649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36650 }
36651 arg1 = reinterpret_cast< wxWindow * >(argp1);
36652 {
36653 PyThreadState* __tstate = wxPyBeginAllowThreads();
36654 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 resultobj = SWIG_From_int(static_cast< int >(result));
36659 return resultobj;
36660 fail:
36661 return NULL;
36662 }
36663
36664
36665 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36666 PyObject *resultobj = 0;
36667 wxWindow *arg1 = (wxWindow *) 0 ;
36668 int result;
36669 void *argp1 = 0 ;
36670 int res1 = 0 ;
36671 PyObject *swig_obj[1] ;
36672
36673 if (!args) SWIG_fail;
36674 swig_obj[0] = args;
36675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36676 if (!SWIG_IsOK(res1)) {
36677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36678 }
36679 arg1 = reinterpret_cast< wxWindow * >(argp1);
36680 {
36681 PyThreadState* __tstate = wxPyBeginAllowThreads();
36682 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36683 wxPyEndAllowThreads(__tstate);
36684 if (PyErr_Occurred()) SWIG_fail;
36685 }
36686 resultobj = SWIG_From_int(static_cast< int >(result));
36687 return resultobj;
36688 fail:
36689 return NULL;
36690 }
36691
36692
36693 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36694 PyObject *resultobj = 0;
36695 wxWindow *arg1 = (wxWindow *) 0 ;
36696 wxString *arg2 = 0 ;
36697 int *arg3 = (int *) 0 ;
36698 int *arg4 = (int *) 0 ;
36699 void *argp1 = 0 ;
36700 int res1 = 0 ;
36701 bool temp2 = false ;
36702 int temp3 ;
36703 int res3 = SWIG_TMPOBJ ;
36704 int temp4 ;
36705 int res4 = SWIG_TMPOBJ ;
36706 PyObject * obj0 = 0 ;
36707 PyObject * obj1 = 0 ;
36708 char * kwnames[] = {
36709 (char *) "self",(char *) "string", NULL
36710 };
36711
36712 arg3 = &temp3;
36713 arg4 = &temp4;
36714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36716 if (!SWIG_IsOK(res1)) {
36717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36718 }
36719 arg1 = reinterpret_cast< wxWindow * >(argp1);
36720 {
36721 arg2 = wxString_in_helper(obj1);
36722 if (arg2 == NULL) SWIG_fail;
36723 temp2 = true;
36724 }
36725 {
36726 PyThreadState* __tstate = wxPyBeginAllowThreads();
36727 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36728 wxPyEndAllowThreads(__tstate);
36729 if (PyErr_Occurred()) SWIG_fail;
36730 }
36731 resultobj = SWIG_Py_Void();
36732 if (SWIG_IsTmpObj(res3)) {
36733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36734 } else {
36735 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36737 }
36738 if (SWIG_IsTmpObj(res4)) {
36739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36740 } else {
36741 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36743 }
36744 {
36745 if (temp2)
36746 delete arg2;
36747 }
36748 return resultobj;
36749 fail:
36750 {
36751 if (temp2)
36752 delete arg2;
36753 }
36754 return NULL;
36755 }
36756
36757
36758 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36759 PyObject *resultobj = 0;
36760 wxWindow *arg1 = (wxWindow *) 0 ;
36761 wxString *arg2 = 0 ;
36762 int *arg3 = (int *) 0 ;
36763 int *arg4 = (int *) 0 ;
36764 int *arg5 = (int *) 0 ;
36765 int *arg6 = (int *) 0 ;
36766 wxFont *arg7 = (wxFont *) NULL ;
36767 void *argp1 = 0 ;
36768 int res1 = 0 ;
36769 bool temp2 = false ;
36770 int temp3 ;
36771 int res3 = SWIG_TMPOBJ ;
36772 int temp4 ;
36773 int res4 = SWIG_TMPOBJ ;
36774 int temp5 ;
36775 int res5 = SWIG_TMPOBJ ;
36776 int temp6 ;
36777 int res6 = SWIG_TMPOBJ ;
36778 void *argp7 = 0 ;
36779 int res7 = 0 ;
36780 PyObject * obj0 = 0 ;
36781 PyObject * obj1 = 0 ;
36782 PyObject * obj2 = 0 ;
36783 char * kwnames[] = {
36784 (char *) "self",(char *) "string",(char *) "font", NULL
36785 };
36786
36787 arg3 = &temp3;
36788 arg4 = &temp4;
36789 arg5 = &temp5;
36790 arg6 = &temp6;
36791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36793 if (!SWIG_IsOK(res1)) {
36794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36795 }
36796 arg1 = reinterpret_cast< wxWindow * >(argp1);
36797 {
36798 arg2 = wxString_in_helper(obj1);
36799 if (arg2 == NULL) SWIG_fail;
36800 temp2 = true;
36801 }
36802 if (obj2) {
36803 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36804 if (!SWIG_IsOK(res7)) {
36805 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36806 }
36807 arg7 = reinterpret_cast< wxFont * >(argp7);
36808 }
36809 {
36810 PyThreadState* __tstate = wxPyBeginAllowThreads();
36811 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36812 wxPyEndAllowThreads(__tstate);
36813 if (PyErr_Occurred()) SWIG_fail;
36814 }
36815 resultobj = SWIG_Py_Void();
36816 if (SWIG_IsTmpObj(res3)) {
36817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36818 } else {
36819 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36821 }
36822 if (SWIG_IsTmpObj(res4)) {
36823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36824 } else {
36825 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36827 }
36828 if (SWIG_IsTmpObj(res5)) {
36829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36830 } else {
36831 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36832 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36833 }
36834 if (SWIG_IsTmpObj(res6)) {
36835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36836 } else {
36837 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36839 }
36840 {
36841 if (temp2)
36842 delete arg2;
36843 }
36844 return resultobj;
36845 fail:
36846 {
36847 if (temp2)
36848 delete arg2;
36849 }
36850 return NULL;
36851 }
36852
36853
36854 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36855 PyObject *resultobj = 0;
36856 wxWindow *arg1 = (wxWindow *) 0 ;
36857 int *arg2 = (int *) 0 ;
36858 int *arg3 = (int *) 0 ;
36859 void *argp1 = 0 ;
36860 int res1 = 0 ;
36861 int temp2 ;
36862 int res2 = 0 ;
36863 int temp3 ;
36864 int res3 = 0 ;
36865 PyObject * obj0 = 0 ;
36866 PyObject * obj1 = 0 ;
36867 PyObject * obj2 = 0 ;
36868 char * kwnames[] = {
36869 (char *) "self",(char *) "x",(char *) "y", NULL
36870 };
36871
36872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36874 if (!SWIG_IsOK(res1)) {
36875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36876 }
36877 arg1 = reinterpret_cast< wxWindow * >(argp1);
36878 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36879 int val;
36880 int ecode = SWIG_AsVal_int(obj1, &val);
36881 if (!SWIG_IsOK(ecode)) {
36882 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36883 }
36884 temp2 = static_cast< int >(val);
36885 arg2 = &temp2;
36886 res2 = SWIG_AddTmpMask(ecode);
36887 }
36888 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36889 int val;
36890 int ecode = SWIG_AsVal_int(obj2, &val);
36891 if (!SWIG_IsOK(ecode)) {
36892 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36893 }
36894 temp3 = static_cast< int >(val);
36895 arg3 = &temp3;
36896 res3 = SWIG_AddTmpMask(ecode);
36897 }
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 resultobj = SWIG_Py_Void();
36905 if (SWIG_IsTmpObj(res2)) {
36906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36907 } else {
36908 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36910 }
36911 if (SWIG_IsTmpObj(res3)) {
36912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36913 } else {
36914 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36916 }
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36924 PyObject *resultobj = 0;
36925 wxWindow *arg1 = (wxWindow *) 0 ;
36926 int *arg2 = (int *) 0 ;
36927 int *arg3 = (int *) 0 ;
36928 void *argp1 = 0 ;
36929 int res1 = 0 ;
36930 int temp2 ;
36931 int res2 = 0 ;
36932 int temp3 ;
36933 int res3 = 0 ;
36934 PyObject * obj0 = 0 ;
36935 PyObject * obj1 = 0 ;
36936 PyObject * obj2 = 0 ;
36937 char * kwnames[] = {
36938 (char *) "self",(char *) "x",(char *) "y", NULL
36939 };
36940
36941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36943 if (!SWIG_IsOK(res1)) {
36944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36945 }
36946 arg1 = reinterpret_cast< wxWindow * >(argp1);
36947 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36948 int val;
36949 int ecode = SWIG_AsVal_int(obj1, &val);
36950 if (!SWIG_IsOK(ecode)) {
36951 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36952 }
36953 temp2 = static_cast< int >(val);
36954 arg2 = &temp2;
36955 res2 = SWIG_AddTmpMask(ecode);
36956 }
36957 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36958 int val;
36959 int ecode = SWIG_AsVal_int(obj2, &val);
36960 if (!SWIG_IsOK(ecode)) {
36961 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36962 }
36963 temp3 = static_cast< int >(val);
36964 arg3 = &temp3;
36965 res3 = SWIG_AddTmpMask(ecode);
36966 }
36967 {
36968 PyThreadState* __tstate = wxPyBeginAllowThreads();
36969 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36970 wxPyEndAllowThreads(__tstate);
36971 if (PyErr_Occurred()) SWIG_fail;
36972 }
36973 resultobj = SWIG_Py_Void();
36974 if (SWIG_IsTmpObj(res2)) {
36975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36976 } else {
36977 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36979 }
36980 if (SWIG_IsTmpObj(res3)) {
36981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36982 } else {
36983 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36985 }
36986 return resultobj;
36987 fail:
36988 return NULL;
36989 }
36990
36991
36992 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36993 PyObject *resultobj = 0;
36994 wxWindow *arg1 = (wxWindow *) 0 ;
36995 wxPoint *arg2 = 0 ;
36996 wxPoint result;
36997 void *argp1 = 0 ;
36998 int res1 = 0 ;
36999 wxPoint temp2 ;
37000 PyObject * obj0 = 0 ;
37001 PyObject * obj1 = 0 ;
37002 char * kwnames[] = {
37003 (char *) "self",(char *) "pt", NULL
37004 };
37005
37006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
37007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37008 if (!SWIG_IsOK(res1)) {
37009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37010 }
37011 arg1 = reinterpret_cast< wxWindow * >(argp1);
37012 {
37013 arg2 = &temp2;
37014 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37015 }
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
37019 wxPyEndAllowThreads(__tstate);
37020 if (PyErr_Occurred()) SWIG_fail;
37021 }
37022 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37023 return resultobj;
37024 fail:
37025 return NULL;
37026 }
37027
37028
37029 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37030 PyObject *resultobj = 0;
37031 wxWindow *arg1 = (wxWindow *) 0 ;
37032 wxPoint *arg2 = 0 ;
37033 wxPoint result;
37034 void *argp1 = 0 ;
37035 int res1 = 0 ;
37036 wxPoint temp2 ;
37037 PyObject * obj0 = 0 ;
37038 PyObject * obj1 = 0 ;
37039 char * kwnames[] = {
37040 (char *) "self",(char *) "pt", NULL
37041 };
37042
37043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
37044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37045 if (!SWIG_IsOK(res1)) {
37046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
37047 }
37048 arg1 = reinterpret_cast< wxWindow * >(argp1);
37049 {
37050 arg2 = &temp2;
37051 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37052 }
37053 {
37054 PyThreadState* __tstate = wxPyBeginAllowThreads();
37055 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
37056 wxPyEndAllowThreads(__tstate);
37057 if (PyErr_Occurred()) SWIG_fail;
37058 }
37059 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37060 return resultobj;
37061 fail:
37062 return NULL;
37063 }
37064
37065
37066 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37067 PyObject *resultobj = 0;
37068 wxWindow *arg1 = (wxWindow *) 0 ;
37069 int arg2 ;
37070 int arg3 ;
37071 wxHitTest result;
37072 void *argp1 = 0 ;
37073 int res1 = 0 ;
37074 int val2 ;
37075 int ecode2 = 0 ;
37076 int val3 ;
37077 int ecode3 = 0 ;
37078 PyObject * obj0 = 0 ;
37079 PyObject * obj1 = 0 ;
37080 PyObject * obj2 = 0 ;
37081 char * kwnames[] = {
37082 (char *) "self",(char *) "x",(char *) "y", NULL
37083 };
37084
37085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37087 if (!SWIG_IsOK(res1)) {
37088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
37089 }
37090 arg1 = reinterpret_cast< wxWindow * >(argp1);
37091 ecode2 = SWIG_AsVal_int(obj1, &val2);
37092 if (!SWIG_IsOK(ecode2)) {
37093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
37094 }
37095 arg2 = static_cast< int >(val2);
37096 ecode3 = SWIG_AsVal_int(obj2, &val3);
37097 if (!SWIG_IsOK(ecode3)) {
37098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
37099 }
37100 arg3 = static_cast< int >(val3);
37101 {
37102 PyThreadState* __tstate = wxPyBeginAllowThreads();
37103 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
37104 wxPyEndAllowThreads(__tstate);
37105 if (PyErr_Occurred()) SWIG_fail;
37106 }
37107 resultobj = SWIG_From_int(static_cast< int >(result));
37108 return resultobj;
37109 fail:
37110 return NULL;
37111 }
37112
37113
37114 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37115 PyObject *resultobj = 0;
37116 wxWindow *arg1 = (wxWindow *) 0 ;
37117 wxPoint *arg2 = 0 ;
37118 wxHitTest result;
37119 void *argp1 = 0 ;
37120 int res1 = 0 ;
37121 wxPoint temp2 ;
37122 PyObject * obj0 = 0 ;
37123 PyObject * obj1 = 0 ;
37124 char * kwnames[] = {
37125 (char *) "self",(char *) "pt", NULL
37126 };
37127
37128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
37129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37130 if (!SWIG_IsOK(res1)) {
37131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
37132 }
37133 arg1 = reinterpret_cast< wxWindow * >(argp1);
37134 {
37135 arg2 = &temp2;
37136 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37137 }
37138 {
37139 PyThreadState* __tstate = wxPyBeginAllowThreads();
37140 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37141 wxPyEndAllowThreads(__tstate);
37142 if (PyErr_Occurred()) SWIG_fail;
37143 }
37144 resultobj = SWIG_From_int(static_cast< int >(result));
37145 return resultobj;
37146 fail:
37147 return NULL;
37148 }
37149
37150
37151 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37152 PyObject *resultobj = 0;
37153 wxWindow *arg1 = (wxWindow *) 0 ;
37154 long arg2 ;
37155 wxBorder result;
37156 void *argp1 = 0 ;
37157 int res1 = 0 ;
37158 long val2 ;
37159 int ecode2 = 0 ;
37160
37161 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37163 if (!SWIG_IsOK(res1)) {
37164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37165 }
37166 arg1 = reinterpret_cast< wxWindow * >(argp1);
37167 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37168 if (!SWIG_IsOK(ecode2)) {
37169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37170 }
37171 arg2 = static_cast< long >(val2);
37172 {
37173 PyThreadState* __tstate = wxPyBeginAllowThreads();
37174 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37175 wxPyEndAllowThreads(__tstate);
37176 if (PyErr_Occurred()) SWIG_fail;
37177 }
37178 resultobj = SWIG_From_int(static_cast< int >(result));
37179 return resultobj;
37180 fail:
37181 return NULL;
37182 }
37183
37184
37185 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37186 PyObject *resultobj = 0;
37187 wxWindow *arg1 = (wxWindow *) 0 ;
37188 wxBorder result;
37189 void *argp1 = 0 ;
37190 int res1 = 0 ;
37191
37192 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37194 if (!SWIG_IsOK(res1)) {
37195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37196 }
37197 arg1 = reinterpret_cast< wxWindow * >(argp1);
37198 {
37199 PyThreadState* __tstate = wxPyBeginAllowThreads();
37200 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37201 wxPyEndAllowThreads(__tstate);
37202 if (PyErr_Occurred()) SWIG_fail;
37203 }
37204 resultobj = SWIG_From_int(static_cast< int >(result));
37205 return resultobj;
37206 fail:
37207 return NULL;
37208 }
37209
37210
37211 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37212 int argc;
37213 PyObject *argv[3];
37214
37215 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37216 --argc;
37217 if (argc == 1) {
37218 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37219 }
37220 if (argc == 2) {
37221 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37222 }
37223
37224 fail:
37225 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37226 return NULL;
37227 }
37228
37229
37230 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37231 PyObject *resultobj = 0;
37232 wxWindow *arg1 = (wxWindow *) 0 ;
37233 long arg2 = (long) wxUPDATE_UI_NONE ;
37234 void *argp1 = 0 ;
37235 int res1 = 0 ;
37236 long val2 ;
37237 int ecode2 = 0 ;
37238 PyObject * obj0 = 0 ;
37239 PyObject * obj1 = 0 ;
37240 char * kwnames[] = {
37241 (char *) "self",(char *) "flags", NULL
37242 };
37243
37244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37246 if (!SWIG_IsOK(res1)) {
37247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37248 }
37249 arg1 = reinterpret_cast< wxWindow * >(argp1);
37250 if (obj1) {
37251 ecode2 = SWIG_AsVal_long(obj1, &val2);
37252 if (!SWIG_IsOK(ecode2)) {
37253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37254 }
37255 arg2 = static_cast< long >(val2);
37256 }
37257 {
37258 PyThreadState* __tstate = wxPyBeginAllowThreads();
37259 (arg1)->UpdateWindowUI(arg2);
37260 wxPyEndAllowThreads(__tstate);
37261 if (PyErr_Occurred()) SWIG_fail;
37262 }
37263 resultobj = SWIG_Py_Void();
37264 return resultobj;
37265 fail:
37266 return NULL;
37267 }
37268
37269
37270 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37271 PyObject *resultobj = 0;
37272 wxWindow *arg1 = (wxWindow *) 0 ;
37273 wxMenu *arg2 = (wxMenu *) 0 ;
37274 int arg3 = (int) -1 ;
37275 int arg4 = (int) -1 ;
37276 bool result;
37277 void *argp1 = 0 ;
37278 int res1 = 0 ;
37279 void *argp2 = 0 ;
37280 int res2 = 0 ;
37281 int val3 ;
37282 int ecode3 = 0 ;
37283 int val4 ;
37284 int ecode4 = 0 ;
37285 PyObject * obj0 = 0 ;
37286 PyObject * obj1 = 0 ;
37287 PyObject * obj2 = 0 ;
37288 PyObject * obj3 = 0 ;
37289 char * kwnames[] = {
37290 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37291 };
37292
37293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37295 if (!SWIG_IsOK(res1)) {
37296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37297 }
37298 arg1 = reinterpret_cast< wxWindow * >(argp1);
37299 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37300 if (!SWIG_IsOK(res2)) {
37301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37302 }
37303 arg2 = reinterpret_cast< wxMenu * >(argp2);
37304 if (obj2) {
37305 ecode3 = SWIG_AsVal_int(obj2, &val3);
37306 if (!SWIG_IsOK(ecode3)) {
37307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37308 }
37309 arg3 = static_cast< int >(val3);
37310 }
37311 if (obj3) {
37312 ecode4 = SWIG_AsVal_int(obj3, &val4);
37313 if (!SWIG_IsOK(ecode4)) {
37314 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37315 }
37316 arg4 = static_cast< int >(val4);
37317 }
37318 {
37319 PyThreadState* __tstate = wxPyBeginAllowThreads();
37320 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37321 wxPyEndAllowThreads(__tstate);
37322 if (PyErr_Occurred()) SWIG_fail;
37323 }
37324 {
37325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37326 }
37327 return resultobj;
37328 fail:
37329 return NULL;
37330 }
37331
37332
37333 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37334 PyObject *resultobj = 0;
37335 wxWindow *arg1 = (wxWindow *) 0 ;
37336 wxMenu *arg2 = (wxMenu *) 0 ;
37337 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37338 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37339 bool result;
37340 void *argp1 = 0 ;
37341 int res1 = 0 ;
37342 void *argp2 = 0 ;
37343 int res2 = 0 ;
37344 wxPoint temp3 ;
37345 PyObject * obj0 = 0 ;
37346 PyObject * obj1 = 0 ;
37347 PyObject * obj2 = 0 ;
37348 char * kwnames[] = {
37349 (char *) "self",(char *) "menu",(char *) "pos", NULL
37350 };
37351
37352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37354 if (!SWIG_IsOK(res1)) {
37355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37356 }
37357 arg1 = reinterpret_cast< wxWindow * >(argp1);
37358 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37359 if (!SWIG_IsOK(res2)) {
37360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37361 }
37362 arg2 = reinterpret_cast< wxMenu * >(argp2);
37363 if (obj2) {
37364 {
37365 arg3 = &temp3;
37366 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37367 }
37368 }
37369 {
37370 PyThreadState* __tstate = wxPyBeginAllowThreads();
37371 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37372 wxPyEndAllowThreads(__tstate);
37373 if (PyErr_Occurred()) SWIG_fail;
37374 }
37375 {
37376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37377 }
37378 return resultobj;
37379 fail:
37380 return NULL;
37381 }
37382
37383
37384 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37385 PyObject *resultobj = 0;
37386 wxWindow *arg1 = (wxWindow *) 0 ;
37387 bool result;
37388 void *argp1 = 0 ;
37389 int res1 = 0 ;
37390 PyObject *swig_obj[1] ;
37391
37392 if (!args) SWIG_fail;
37393 swig_obj[0] = args;
37394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37395 if (!SWIG_IsOK(res1)) {
37396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37397 }
37398 arg1 = reinterpret_cast< wxWindow * >(argp1);
37399 {
37400 PyThreadState* __tstate = wxPyBeginAllowThreads();
37401 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37402 wxPyEndAllowThreads(__tstate);
37403 if (PyErr_Occurred()) SWIG_fail;
37404 }
37405 {
37406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37407 }
37408 return resultobj;
37409 fail:
37410 return NULL;
37411 }
37412
37413
37414 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37415 PyObject *resultobj = 0;
37416 wxWindow *arg1 = (wxWindow *) 0 ;
37417 long result;
37418 void *argp1 = 0 ;
37419 int res1 = 0 ;
37420 PyObject *swig_obj[1] ;
37421
37422 if (!args) SWIG_fail;
37423 swig_obj[0] = args;
37424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37425 if (!SWIG_IsOK(res1)) {
37426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37427 }
37428 arg1 = reinterpret_cast< wxWindow * >(argp1);
37429 {
37430 PyThreadState* __tstate = wxPyBeginAllowThreads();
37431 result = (long)wxWindow_GetHandle(arg1);
37432 wxPyEndAllowThreads(__tstate);
37433 if (PyErr_Occurred()) SWIG_fail;
37434 }
37435 resultobj = SWIG_From_long(static_cast< long >(result));
37436 return resultobj;
37437 fail:
37438 return NULL;
37439 }
37440
37441
37442 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37443 PyObject *resultobj = 0;
37444 wxWindow *arg1 = (wxWindow *) 0 ;
37445 long arg2 ;
37446 void *argp1 = 0 ;
37447 int res1 = 0 ;
37448 long val2 ;
37449 int ecode2 = 0 ;
37450 PyObject * obj0 = 0 ;
37451 PyObject * obj1 = 0 ;
37452 char * kwnames[] = {
37453 (char *) "self",(char *) "handle", NULL
37454 };
37455
37456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37458 if (!SWIG_IsOK(res1)) {
37459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37460 }
37461 arg1 = reinterpret_cast< wxWindow * >(argp1);
37462 ecode2 = SWIG_AsVal_long(obj1, &val2);
37463 if (!SWIG_IsOK(ecode2)) {
37464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37465 }
37466 arg2 = static_cast< long >(val2);
37467 {
37468 PyThreadState* __tstate = wxPyBeginAllowThreads();
37469 wxWindow_AssociateHandle(arg1,arg2);
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 resultobj = SWIG_Py_Void();
37474 return resultobj;
37475 fail:
37476 return NULL;
37477 }
37478
37479
37480 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37481 PyObject *resultobj = 0;
37482 wxWindow *arg1 = (wxWindow *) 0 ;
37483 void *argp1 = 0 ;
37484 int res1 = 0 ;
37485 PyObject *swig_obj[1] ;
37486
37487 if (!args) SWIG_fail;
37488 swig_obj[0] = args;
37489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37490 if (!SWIG_IsOK(res1)) {
37491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37492 }
37493 arg1 = reinterpret_cast< wxWindow * >(argp1);
37494 {
37495 PyThreadState* __tstate = wxPyBeginAllowThreads();
37496 (arg1)->DissociateHandle();
37497 wxPyEndAllowThreads(__tstate);
37498 if (PyErr_Occurred()) SWIG_fail;
37499 }
37500 resultobj = SWIG_Py_Void();
37501 return resultobj;
37502 fail:
37503 return NULL;
37504 }
37505
37506
37507 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37508 PyObject *resultobj = 0;
37509 wxWindow *arg1 = (wxWindow *) 0 ;
37510 wxPaintEvent *arg2 = 0 ;
37511 void *argp1 = 0 ;
37512 int res1 = 0 ;
37513 void *argp2 = 0 ;
37514 int res2 = 0 ;
37515 PyObject * obj0 = 0 ;
37516 PyObject * obj1 = 0 ;
37517 char * kwnames[] = {
37518 (char *) "self",(char *) "event", NULL
37519 };
37520
37521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
37522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37523 if (!SWIG_IsOK(res1)) {
37524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
37525 }
37526 arg1 = reinterpret_cast< wxWindow * >(argp1);
37527 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
37528 if (!SWIG_IsOK(res2)) {
37529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37530 }
37531 if (!argp2) {
37532 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37533 }
37534 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 (arg1)->OnPaint(*arg2);
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 resultobj = SWIG_Py_Void();
37542 return resultobj;
37543 fail:
37544 return NULL;
37545 }
37546
37547
37548 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37549 PyObject *resultobj = 0;
37550 wxWindow *arg1 = (wxWindow *) 0 ;
37551 int arg2 ;
37552 bool result;
37553 void *argp1 = 0 ;
37554 int res1 = 0 ;
37555 int val2 ;
37556 int ecode2 = 0 ;
37557 PyObject * obj0 = 0 ;
37558 PyObject * obj1 = 0 ;
37559 char * kwnames[] = {
37560 (char *) "self",(char *) "orient", NULL
37561 };
37562
37563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37565 if (!SWIG_IsOK(res1)) {
37566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37567 }
37568 arg1 = reinterpret_cast< wxWindow * >(argp1);
37569 ecode2 = SWIG_AsVal_int(obj1, &val2);
37570 if (!SWIG_IsOK(ecode2)) {
37571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37572 }
37573 arg2 = static_cast< int >(val2);
37574 {
37575 PyThreadState* __tstate = wxPyBeginAllowThreads();
37576 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37577 wxPyEndAllowThreads(__tstate);
37578 if (PyErr_Occurred()) SWIG_fail;
37579 }
37580 {
37581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37582 }
37583 return resultobj;
37584 fail:
37585 return NULL;
37586 }
37587
37588
37589 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37590 PyObject *resultobj = 0;
37591 wxWindow *arg1 = (wxWindow *) 0 ;
37592 int arg2 ;
37593 int arg3 ;
37594 int arg4 ;
37595 int arg5 ;
37596 bool arg6 = (bool) true ;
37597 void *argp1 = 0 ;
37598 int res1 = 0 ;
37599 int val2 ;
37600 int ecode2 = 0 ;
37601 int val3 ;
37602 int ecode3 = 0 ;
37603 int val4 ;
37604 int ecode4 = 0 ;
37605 int val5 ;
37606 int ecode5 = 0 ;
37607 bool val6 ;
37608 int ecode6 = 0 ;
37609 PyObject * obj0 = 0 ;
37610 PyObject * obj1 = 0 ;
37611 PyObject * obj2 = 0 ;
37612 PyObject * obj3 = 0 ;
37613 PyObject * obj4 = 0 ;
37614 PyObject * obj5 = 0 ;
37615 char * kwnames[] = {
37616 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37617 };
37618
37619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37621 if (!SWIG_IsOK(res1)) {
37622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37623 }
37624 arg1 = reinterpret_cast< wxWindow * >(argp1);
37625 ecode2 = SWIG_AsVal_int(obj1, &val2);
37626 if (!SWIG_IsOK(ecode2)) {
37627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37628 }
37629 arg2 = static_cast< int >(val2);
37630 ecode3 = SWIG_AsVal_int(obj2, &val3);
37631 if (!SWIG_IsOK(ecode3)) {
37632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37633 }
37634 arg3 = static_cast< int >(val3);
37635 ecode4 = SWIG_AsVal_int(obj3, &val4);
37636 if (!SWIG_IsOK(ecode4)) {
37637 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37638 }
37639 arg4 = static_cast< int >(val4);
37640 ecode5 = SWIG_AsVal_int(obj4, &val5);
37641 if (!SWIG_IsOK(ecode5)) {
37642 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37643 }
37644 arg5 = static_cast< int >(val5);
37645 if (obj5) {
37646 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37647 if (!SWIG_IsOK(ecode6)) {
37648 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37649 }
37650 arg6 = static_cast< bool >(val6);
37651 }
37652 {
37653 PyThreadState* __tstate = wxPyBeginAllowThreads();
37654 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37655 wxPyEndAllowThreads(__tstate);
37656 if (PyErr_Occurred()) SWIG_fail;
37657 }
37658 resultobj = SWIG_Py_Void();
37659 return resultobj;
37660 fail:
37661 return NULL;
37662 }
37663
37664
37665 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37666 PyObject *resultobj = 0;
37667 wxWindow *arg1 = (wxWindow *) 0 ;
37668 int arg2 ;
37669 int arg3 ;
37670 bool arg4 = (bool) true ;
37671 void *argp1 = 0 ;
37672 int res1 = 0 ;
37673 int val2 ;
37674 int ecode2 = 0 ;
37675 int val3 ;
37676 int ecode3 = 0 ;
37677 bool val4 ;
37678 int ecode4 = 0 ;
37679 PyObject * obj0 = 0 ;
37680 PyObject * obj1 = 0 ;
37681 PyObject * obj2 = 0 ;
37682 PyObject * obj3 = 0 ;
37683 char * kwnames[] = {
37684 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37685 };
37686
37687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37689 if (!SWIG_IsOK(res1)) {
37690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37691 }
37692 arg1 = reinterpret_cast< wxWindow * >(argp1);
37693 ecode2 = SWIG_AsVal_int(obj1, &val2);
37694 if (!SWIG_IsOK(ecode2)) {
37695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37696 }
37697 arg2 = static_cast< int >(val2);
37698 ecode3 = SWIG_AsVal_int(obj2, &val3);
37699 if (!SWIG_IsOK(ecode3)) {
37700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37701 }
37702 arg3 = static_cast< int >(val3);
37703 if (obj3) {
37704 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37705 if (!SWIG_IsOK(ecode4)) {
37706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37707 }
37708 arg4 = static_cast< bool >(val4);
37709 }
37710 {
37711 PyThreadState* __tstate = wxPyBeginAllowThreads();
37712 (arg1)->SetScrollPos(arg2,arg3,arg4);
37713 wxPyEndAllowThreads(__tstate);
37714 if (PyErr_Occurred()) SWIG_fail;
37715 }
37716 resultobj = SWIG_Py_Void();
37717 return resultobj;
37718 fail:
37719 return NULL;
37720 }
37721
37722
37723 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37724 PyObject *resultobj = 0;
37725 wxWindow *arg1 = (wxWindow *) 0 ;
37726 int arg2 ;
37727 int result;
37728 void *argp1 = 0 ;
37729 int res1 = 0 ;
37730 int val2 ;
37731 int ecode2 = 0 ;
37732 PyObject * obj0 = 0 ;
37733 PyObject * obj1 = 0 ;
37734 char * kwnames[] = {
37735 (char *) "self",(char *) "orientation", NULL
37736 };
37737
37738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37740 if (!SWIG_IsOK(res1)) {
37741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37742 }
37743 arg1 = reinterpret_cast< wxWindow * >(argp1);
37744 ecode2 = SWIG_AsVal_int(obj1, &val2);
37745 if (!SWIG_IsOK(ecode2)) {
37746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37747 }
37748 arg2 = static_cast< int >(val2);
37749 {
37750 PyThreadState* __tstate = wxPyBeginAllowThreads();
37751 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37752 wxPyEndAllowThreads(__tstate);
37753 if (PyErr_Occurred()) SWIG_fail;
37754 }
37755 resultobj = SWIG_From_int(static_cast< int >(result));
37756 return resultobj;
37757 fail:
37758 return NULL;
37759 }
37760
37761
37762 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37763 PyObject *resultobj = 0;
37764 wxWindow *arg1 = (wxWindow *) 0 ;
37765 int arg2 ;
37766 int result;
37767 void *argp1 = 0 ;
37768 int res1 = 0 ;
37769 int val2 ;
37770 int ecode2 = 0 ;
37771 PyObject * obj0 = 0 ;
37772 PyObject * obj1 = 0 ;
37773 char * kwnames[] = {
37774 (char *) "self",(char *) "orientation", NULL
37775 };
37776
37777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37779 if (!SWIG_IsOK(res1)) {
37780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37781 }
37782 arg1 = reinterpret_cast< wxWindow * >(argp1);
37783 ecode2 = SWIG_AsVal_int(obj1, &val2);
37784 if (!SWIG_IsOK(ecode2)) {
37785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37786 }
37787 arg2 = static_cast< int >(val2);
37788 {
37789 PyThreadState* __tstate = wxPyBeginAllowThreads();
37790 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37791 wxPyEndAllowThreads(__tstate);
37792 if (PyErr_Occurred()) SWIG_fail;
37793 }
37794 resultobj = SWIG_From_int(static_cast< int >(result));
37795 return resultobj;
37796 fail:
37797 return NULL;
37798 }
37799
37800
37801 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37802 PyObject *resultobj = 0;
37803 wxWindow *arg1 = (wxWindow *) 0 ;
37804 int arg2 ;
37805 int result;
37806 void *argp1 = 0 ;
37807 int res1 = 0 ;
37808 int val2 ;
37809 int ecode2 = 0 ;
37810 PyObject * obj0 = 0 ;
37811 PyObject * obj1 = 0 ;
37812 char * kwnames[] = {
37813 (char *) "self",(char *) "orientation", NULL
37814 };
37815
37816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37818 if (!SWIG_IsOK(res1)) {
37819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37820 }
37821 arg1 = reinterpret_cast< wxWindow * >(argp1);
37822 ecode2 = SWIG_AsVal_int(obj1, &val2);
37823 if (!SWIG_IsOK(ecode2)) {
37824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37825 }
37826 arg2 = static_cast< int >(val2);
37827 {
37828 PyThreadState* __tstate = wxPyBeginAllowThreads();
37829 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37830 wxPyEndAllowThreads(__tstate);
37831 if (PyErr_Occurred()) SWIG_fail;
37832 }
37833 resultobj = SWIG_From_int(static_cast< int >(result));
37834 return resultobj;
37835 fail:
37836 return NULL;
37837 }
37838
37839
37840 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37841 PyObject *resultobj = 0;
37842 wxWindow *arg1 = (wxWindow *) 0 ;
37843 int arg2 ;
37844 int arg3 ;
37845 wxRect *arg4 = (wxRect *) NULL ;
37846 void *argp1 = 0 ;
37847 int res1 = 0 ;
37848 int val2 ;
37849 int ecode2 = 0 ;
37850 int val3 ;
37851 int ecode3 = 0 ;
37852 void *argp4 = 0 ;
37853 int res4 = 0 ;
37854 PyObject * obj0 = 0 ;
37855 PyObject * obj1 = 0 ;
37856 PyObject * obj2 = 0 ;
37857 PyObject * obj3 = 0 ;
37858 char * kwnames[] = {
37859 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37860 };
37861
37862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37864 if (!SWIG_IsOK(res1)) {
37865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37866 }
37867 arg1 = reinterpret_cast< wxWindow * >(argp1);
37868 ecode2 = SWIG_AsVal_int(obj1, &val2);
37869 if (!SWIG_IsOK(ecode2)) {
37870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37871 }
37872 arg2 = static_cast< int >(val2);
37873 ecode3 = SWIG_AsVal_int(obj2, &val3);
37874 if (!SWIG_IsOK(ecode3)) {
37875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37876 }
37877 arg3 = static_cast< int >(val3);
37878 if (obj3) {
37879 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37880 if (!SWIG_IsOK(res4)) {
37881 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37882 }
37883 arg4 = reinterpret_cast< wxRect * >(argp4);
37884 }
37885 {
37886 PyThreadState* __tstate = wxPyBeginAllowThreads();
37887 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37888 wxPyEndAllowThreads(__tstate);
37889 if (PyErr_Occurred()) SWIG_fail;
37890 }
37891 resultobj = SWIG_Py_Void();
37892 return resultobj;
37893 fail:
37894 return NULL;
37895 }
37896
37897
37898 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37899 PyObject *resultobj = 0;
37900 wxWindow *arg1 = (wxWindow *) 0 ;
37901 int arg2 ;
37902 bool result;
37903 void *argp1 = 0 ;
37904 int res1 = 0 ;
37905 int val2 ;
37906 int ecode2 = 0 ;
37907 PyObject * obj0 = 0 ;
37908 PyObject * obj1 = 0 ;
37909 char * kwnames[] = {
37910 (char *) "self",(char *) "lines", NULL
37911 };
37912
37913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37915 if (!SWIG_IsOK(res1)) {
37916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37917 }
37918 arg1 = reinterpret_cast< wxWindow * >(argp1);
37919 ecode2 = SWIG_AsVal_int(obj1, &val2);
37920 if (!SWIG_IsOK(ecode2)) {
37921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37922 }
37923 arg2 = static_cast< int >(val2);
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 result = (bool)(arg1)->ScrollLines(arg2);
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 {
37931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37932 }
37933 return resultobj;
37934 fail:
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37940 PyObject *resultobj = 0;
37941 wxWindow *arg1 = (wxWindow *) 0 ;
37942 int arg2 ;
37943 bool result;
37944 void *argp1 = 0 ;
37945 int res1 = 0 ;
37946 int val2 ;
37947 int ecode2 = 0 ;
37948 PyObject * obj0 = 0 ;
37949 PyObject * obj1 = 0 ;
37950 char * kwnames[] = {
37951 (char *) "self",(char *) "pages", NULL
37952 };
37953
37954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37956 if (!SWIG_IsOK(res1)) {
37957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37958 }
37959 arg1 = reinterpret_cast< wxWindow * >(argp1);
37960 ecode2 = SWIG_AsVal_int(obj1, &val2);
37961 if (!SWIG_IsOK(ecode2)) {
37962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37963 }
37964 arg2 = static_cast< int >(val2);
37965 {
37966 PyThreadState* __tstate = wxPyBeginAllowThreads();
37967 result = (bool)(arg1)->ScrollPages(arg2);
37968 wxPyEndAllowThreads(__tstate);
37969 if (PyErr_Occurred()) SWIG_fail;
37970 }
37971 {
37972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37973 }
37974 return resultobj;
37975 fail:
37976 return NULL;
37977 }
37978
37979
37980 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37981 PyObject *resultobj = 0;
37982 wxWindow *arg1 = (wxWindow *) 0 ;
37983 bool result;
37984 void *argp1 = 0 ;
37985 int res1 = 0 ;
37986 PyObject *swig_obj[1] ;
37987
37988 if (!args) SWIG_fail;
37989 swig_obj[0] = args;
37990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37991 if (!SWIG_IsOK(res1)) {
37992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37993 }
37994 arg1 = reinterpret_cast< wxWindow * >(argp1);
37995 {
37996 PyThreadState* __tstate = wxPyBeginAllowThreads();
37997 result = (bool)(arg1)->LineUp();
37998 wxPyEndAllowThreads(__tstate);
37999 if (PyErr_Occurred()) SWIG_fail;
38000 }
38001 {
38002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38003 }
38004 return resultobj;
38005 fail:
38006 return NULL;
38007 }
38008
38009
38010 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38011 PyObject *resultobj = 0;
38012 wxWindow *arg1 = (wxWindow *) 0 ;
38013 bool result;
38014 void *argp1 = 0 ;
38015 int res1 = 0 ;
38016 PyObject *swig_obj[1] ;
38017
38018 if (!args) SWIG_fail;
38019 swig_obj[0] = args;
38020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38021 if (!SWIG_IsOK(res1)) {
38022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38023 }
38024 arg1 = reinterpret_cast< wxWindow * >(argp1);
38025 {
38026 PyThreadState* __tstate = wxPyBeginAllowThreads();
38027 result = (bool)(arg1)->LineDown();
38028 wxPyEndAllowThreads(__tstate);
38029 if (PyErr_Occurred()) SWIG_fail;
38030 }
38031 {
38032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38033 }
38034 return resultobj;
38035 fail:
38036 return NULL;
38037 }
38038
38039
38040 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38041 PyObject *resultobj = 0;
38042 wxWindow *arg1 = (wxWindow *) 0 ;
38043 bool result;
38044 void *argp1 = 0 ;
38045 int res1 = 0 ;
38046 PyObject *swig_obj[1] ;
38047
38048 if (!args) SWIG_fail;
38049 swig_obj[0] = args;
38050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38051 if (!SWIG_IsOK(res1)) {
38052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
38053 }
38054 arg1 = reinterpret_cast< wxWindow * >(argp1);
38055 {
38056 PyThreadState* __tstate = wxPyBeginAllowThreads();
38057 result = (bool)(arg1)->PageUp();
38058 wxPyEndAllowThreads(__tstate);
38059 if (PyErr_Occurred()) SWIG_fail;
38060 }
38061 {
38062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38063 }
38064 return resultobj;
38065 fail:
38066 return NULL;
38067 }
38068
38069
38070 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38071 PyObject *resultobj = 0;
38072 wxWindow *arg1 = (wxWindow *) 0 ;
38073 bool result;
38074 void *argp1 = 0 ;
38075 int res1 = 0 ;
38076 PyObject *swig_obj[1] ;
38077
38078 if (!args) SWIG_fail;
38079 swig_obj[0] = args;
38080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38081 if (!SWIG_IsOK(res1)) {
38082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38083 }
38084 arg1 = reinterpret_cast< wxWindow * >(argp1);
38085 {
38086 PyThreadState* __tstate = wxPyBeginAllowThreads();
38087 result = (bool)(arg1)->PageDown();
38088 wxPyEndAllowThreads(__tstate);
38089 if (PyErr_Occurred()) SWIG_fail;
38090 }
38091 {
38092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38093 }
38094 return resultobj;
38095 fail:
38096 return NULL;
38097 }
38098
38099
38100 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38101 PyObject *resultobj = 0;
38102 wxWindow *arg1 = (wxWindow *) 0 ;
38103 wxString *arg2 = 0 ;
38104 void *argp1 = 0 ;
38105 int res1 = 0 ;
38106 bool temp2 = false ;
38107 PyObject * obj0 = 0 ;
38108 PyObject * obj1 = 0 ;
38109 char * kwnames[] = {
38110 (char *) "self",(char *) "text", NULL
38111 };
38112
38113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
38114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38115 if (!SWIG_IsOK(res1)) {
38116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
38117 }
38118 arg1 = reinterpret_cast< wxWindow * >(argp1);
38119 {
38120 arg2 = wxString_in_helper(obj1);
38121 if (arg2 == NULL) SWIG_fail;
38122 temp2 = true;
38123 }
38124 {
38125 PyThreadState* __tstate = wxPyBeginAllowThreads();
38126 (arg1)->SetHelpText((wxString const &)*arg2);
38127 wxPyEndAllowThreads(__tstate);
38128 if (PyErr_Occurred()) SWIG_fail;
38129 }
38130 resultobj = SWIG_Py_Void();
38131 {
38132 if (temp2)
38133 delete arg2;
38134 }
38135 return resultobj;
38136 fail:
38137 {
38138 if (temp2)
38139 delete arg2;
38140 }
38141 return NULL;
38142 }
38143
38144
38145 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38146 PyObject *resultobj = 0;
38147 wxWindow *arg1 = (wxWindow *) 0 ;
38148 wxString *arg2 = 0 ;
38149 void *argp1 = 0 ;
38150 int res1 = 0 ;
38151 bool temp2 = false ;
38152 PyObject * obj0 = 0 ;
38153 PyObject * obj1 = 0 ;
38154 char * kwnames[] = {
38155 (char *) "self",(char *) "text", NULL
38156 };
38157
38158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
38159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
38162 }
38163 arg1 = reinterpret_cast< wxWindow * >(argp1);
38164 {
38165 arg2 = wxString_in_helper(obj1);
38166 if (arg2 == NULL) SWIG_fail;
38167 temp2 = true;
38168 }
38169 {
38170 PyThreadState* __tstate = wxPyBeginAllowThreads();
38171 (arg1)->SetHelpTextForId((wxString const &)*arg2);
38172 wxPyEndAllowThreads(__tstate);
38173 if (PyErr_Occurred()) SWIG_fail;
38174 }
38175 resultobj = SWIG_Py_Void();
38176 {
38177 if (temp2)
38178 delete arg2;
38179 }
38180 return resultobj;
38181 fail:
38182 {
38183 if (temp2)
38184 delete arg2;
38185 }
38186 return NULL;
38187 }
38188
38189
38190 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38191 PyObject *resultobj = 0;
38192 wxWindow *arg1 = (wxWindow *) 0 ;
38193 wxPoint *arg2 = 0 ;
38194 wxHelpEvent::Origin arg3 ;
38195 wxString result;
38196 void *argp1 = 0 ;
38197 int res1 = 0 ;
38198 wxPoint temp2 ;
38199 void *argp3 ;
38200 int res3 = 0 ;
38201 PyObject * obj0 = 0 ;
38202 PyObject * obj1 = 0 ;
38203 PyObject * obj2 = 0 ;
38204 char * kwnames[] = {
38205 (char *) "self",(char *) "pt",(char *) "origin", NULL
38206 };
38207
38208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38210 if (!SWIG_IsOK(res1)) {
38211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38212 }
38213 arg1 = reinterpret_cast< wxWindow * >(argp1);
38214 {
38215 arg2 = &temp2;
38216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38217 }
38218 {
38219 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38220 if (!SWIG_IsOK(res3)) {
38221 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38222 }
38223 if (!argp3) {
38224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38225 } else {
38226 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38227 arg3 = *temp;
38228 if (SWIG_IsNewObj(res3)) delete temp;
38229 }
38230 }
38231 {
38232 PyThreadState* __tstate = wxPyBeginAllowThreads();
38233 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38234 wxPyEndAllowThreads(__tstate);
38235 if (PyErr_Occurred()) SWIG_fail;
38236 }
38237 {
38238 #if wxUSE_UNICODE
38239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38240 #else
38241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38242 #endif
38243 }
38244 return resultobj;
38245 fail:
38246 return NULL;
38247 }
38248
38249
38250 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38251 PyObject *resultobj = 0;
38252 wxWindow *arg1 = (wxWindow *) 0 ;
38253 wxString result;
38254 void *argp1 = 0 ;
38255 int res1 = 0 ;
38256 PyObject *swig_obj[1] ;
38257
38258 if (!args) SWIG_fail;
38259 swig_obj[0] = args;
38260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38261 if (!SWIG_IsOK(res1)) {
38262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38263 }
38264 arg1 = reinterpret_cast< wxWindow * >(argp1);
38265 {
38266 PyThreadState* __tstate = wxPyBeginAllowThreads();
38267 result = ((wxWindow const *)arg1)->GetHelpText();
38268 wxPyEndAllowThreads(__tstate);
38269 if (PyErr_Occurred()) SWIG_fail;
38270 }
38271 {
38272 #if wxUSE_UNICODE
38273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38274 #else
38275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38276 #endif
38277 }
38278 return resultobj;
38279 fail:
38280 return NULL;
38281 }
38282
38283
38284 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38285 PyObject *resultobj = 0;
38286 wxWindow *arg1 = (wxWindow *) 0 ;
38287 wxString *arg2 = 0 ;
38288 void *argp1 = 0 ;
38289 int res1 = 0 ;
38290 bool temp2 = false ;
38291 PyObject * obj0 = 0 ;
38292 PyObject * obj1 = 0 ;
38293 char * kwnames[] = {
38294 (char *) "self",(char *) "tip", NULL
38295 };
38296
38297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38299 if (!SWIG_IsOK(res1)) {
38300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38301 }
38302 arg1 = reinterpret_cast< wxWindow * >(argp1);
38303 {
38304 arg2 = wxString_in_helper(obj1);
38305 if (arg2 == NULL) SWIG_fail;
38306 temp2 = true;
38307 }
38308 {
38309 PyThreadState* __tstate = wxPyBeginAllowThreads();
38310 (arg1)->SetToolTip((wxString const &)*arg2);
38311 wxPyEndAllowThreads(__tstate);
38312 if (PyErr_Occurred()) SWIG_fail;
38313 }
38314 resultobj = SWIG_Py_Void();
38315 {
38316 if (temp2)
38317 delete arg2;
38318 }
38319 return resultobj;
38320 fail:
38321 {
38322 if (temp2)
38323 delete arg2;
38324 }
38325 return NULL;
38326 }
38327
38328
38329 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38330 PyObject *resultobj = 0;
38331 wxWindow *arg1 = (wxWindow *) 0 ;
38332 wxToolTip *arg2 = (wxToolTip *) 0 ;
38333 void *argp1 = 0 ;
38334 int res1 = 0 ;
38335 int res2 = 0 ;
38336 PyObject * obj0 = 0 ;
38337 PyObject * obj1 = 0 ;
38338 char * kwnames[] = {
38339 (char *) "self",(char *) "tip", NULL
38340 };
38341
38342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38344 if (!SWIG_IsOK(res1)) {
38345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38346 }
38347 arg1 = reinterpret_cast< wxWindow * >(argp1);
38348 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38349 if (!SWIG_IsOK(res2)) {
38350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38351 }
38352 {
38353 PyThreadState* __tstate = wxPyBeginAllowThreads();
38354 (arg1)->SetToolTip(arg2);
38355 wxPyEndAllowThreads(__tstate);
38356 if (PyErr_Occurred()) SWIG_fail;
38357 }
38358 resultobj = SWIG_Py_Void();
38359 return resultobj;
38360 fail:
38361 return NULL;
38362 }
38363
38364
38365 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38366 PyObject *resultobj = 0;
38367 wxWindow *arg1 = (wxWindow *) 0 ;
38368 wxToolTip *result = 0 ;
38369 void *argp1 = 0 ;
38370 int res1 = 0 ;
38371 PyObject *swig_obj[1] ;
38372
38373 if (!args) SWIG_fail;
38374 swig_obj[0] = args;
38375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38376 if (!SWIG_IsOK(res1)) {
38377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38378 }
38379 arg1 = reinterpret_cast< wxWindow * >(argp1);
38380 {
38381 PyThreadState* __tstate = wxPyBeginAllowThreads();
38382 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38383 wxPyEndAllowThreads(__tstate);
38384 if (PyErr_Occurred()) SWIG_fail;
38385 }
38386 {
38387 resultobj = wxPyMake_wxObject(result, (bool)0);
38388 }
38389 return resultobj;
38390 fail:
38391 return NULL;
38392 }
38393
38394
38395 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj = 0;
38397 wxWindow *arg1 = (wxWindow *) 0 ;
38398 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38399 void *argp1 = 0 ;
38400 int res1 = 0 ;
38401 int res2 = 0 ;
38402 PyObject * obj0 = 0 ;
38403 PyObject * obj1 = 0 ;
38404 char * kwnames[] = {
38405 (char *) "self",(char *) "dropTarget", NULL
38406 };
38407
38408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38410 if (!SWIG_IsOK(res1)) {
38411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38412 }
38413 arg1 = reinterpret_cast< wxWindow * >(argp1);
38414 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38415 if (!SWIG_IsOK(res2)) {
38416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38417 }
38418 {
38419 PyThreadState* __tstate = wxPyBeginAllowThreads();
38420 (arg1)->SetDropTarget(arg2);
38421 wxPyEndAllowThreads(__tstate);
38422 if (PyErr_Occurred()) SWIG_fail;
38423 }
38424 resultobj = SWIG_Py_Void();
38425 return resultobj;
38426 fail:
38427 return NULL;
38428 }
38429
38430
38431 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38432 PyObject *resultobj = 0;
38433 wxWindow *arg1 = (wxWindow *) 0 ;
38434 wxPyDropTarget *result = 0 ;
38435 void *argp1 = 0 ;
38436 int res1 = 0 ;
38437 PyObject *swig_obj[1] ;
38438
38439 if (!args) SWIG_fail;
38440 swig_obj[0] = args;
38441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38442 if (!SWIG_IsOK(res1)) {
38443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38444 }
38445 arg1 = reinterpret_cast< wxWindow * >(argp1);
38446 {
38447 PyThreadState* __tstate = wxPyBeginAllowThreads();
38448 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38449 wxPyEndAllowThreads(__tstate);
38450 if (PyErr_Occurred()) SWIG_fail;
38451 }
38452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38453 return resultobj;
38454 fail:
38455 return NULL;
38456 }
38457
38458
38459 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38460 PyObject *resultobj = 0;
38461 wxWindow *arg1 = (wxWindow *) 0 ;
38462 bool arg2 ;
38463 void *argp1 = 0 ;
38464 int res1 = 0 ;
38465 bool val2 ;
38466 int ecode2 = 0 ;
38467 PyObject * obj0 = 0 ;
38468 PyObject * obj1 = 0 ;
38469 char * kwnames[] = {
38470 (char *) "self",(char *) "accept", NULL
38471 };
38472
38473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38475 if (!SWIG_IsOK(res1)) {
38476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38477 }
38478 arg1 = reinterpret_cast< wxWindow * >(argp1);
38479 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38480 if (!SWIG_IsOK(ecode2)) {
38481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38482 }
38483 arg2 = static_cast< bool >(val2);
38484 {
38485 PyThreadState* __tstate = wxPyBeginAllowThreads();
38486 (arg1)->DragAcceptFiles(arg2);
38487 wxPyEndAllowThreads(__tstate);
38488 if (PyErr_Occurred()) SWIG_fail;
38489 }
38490 resultobj = SWIG_Py_Void();
38491 return resultobj;
38492 fail:
38493 return NULL;
38494 }
38495
38496
38497 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38498 PyObject *resultobj = 0;
38499 wxWindow *arg1 = (wxWindow *) 0 ;
38500 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38501 void *argp1 = 0 ;
38502 int res1 = 0 ;
38503 int res2 = 0 ;
38504 PyObject * obj0 = 0 ;
38505 PyObject * obj1 = 0 ;
38506 char * kwnames[] = {
38507 (char *) "self",(char *) "constraints", NULL
38508 };
38509
38510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38512 if (!SWIG_IsOK(res1)) {
38513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38514 }
38515 arg1 = reinterpret_cast< wxWindow * >(argp1);
38516 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38517 if (!SWIG_IsOK(res2)) {
38518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38519 }
38520 {
38521 PyThreadState* __tstate = wxPyBeginAllowThreads();
38522 (arg1)->SetConstraints(arg2);
38523 wxPyEndAllowThreads(__tstate);
38524 if (PyErr_Occurred()) SWIG_fail;
38525 }
38526 resultobj = SWIG_Py_Void();
38527 return resultobj;
38528 fail:
38529 return NULL;
38530 }
38531
38532
38533 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38534 PyObject *resultobj = 0;
38535 wxWindow *arg1 = (wxWindow *) 0 ;
38536 wxLayoutConstraints *result = 0 ;
38537 void *argp1 = 0 ;
38538 int res1 = 0 ;
38539 PyObject *swig_obj[1] ;
38540
38541 if (!args) SWIG_fail;
38542 swig_obj[0] = args;
38543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38544 if (!SWIG_IsOK(res1)) {
38545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38546 }
38547 arg1 = reinterpret_cast< wxWindow * >(argp1);
38548 {
38549 PyThreadState* __tstate = wxPyBeginAllowThreads();
38550 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38551 wxPyEndAllowThreads(__tstate);
38552 if (PyErr_Occurred()) SWIG_fail;
38553 }
38554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38555 return resultobj;
38556 fail:
38557 return NULL;
38558 }
38559
38560
38561 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38562 PyObject *resultobj = 0;
38563 wxWindow *arg1 = (wxWindow *) 0 ;
38564 bool arg2 ;
38565 void *argp1 = 0 ;
38566 int res1 = 0 ;
38567 bool val2 ;
38568 int ecode2 = 0 ;
38569 PyObject * obj0 = 0 ;
38570 PyObject * obj1 = 0 ;
38571 char * kwnames[] = {
38572 (char *) "self",(char *) "autoLayout", NULL
38573 };
38574
38575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38577 if (!SWIG_IsOK(res1)) {
38578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38579 }
38580 arg1 = reinterpret_cast< wxWindow * >(argp1);
38581 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38582 if (!SWIG_IsOK(ecode2)) {
38583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38584 }
38585 arg2 = static_cast< bool >(val2);
38586 {
38587 PyThreadState* __tstate = wxPyBeginAllowThreads();
38588 (arg1)->SetAutoLayout(arg2);
38589 wxPyEndAllowThreads(__tstate);
38590 if (PyErr_Occurred()) SWIG_fail;
38591 }
38592 resultobj = SWIG_Py_Void();
38593 return resultobj;
38594 fail:
38595 return NULL;
38596 }
38597
38598
38599 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38600 PyObject *resultobj = 0;
38601 wxWindow *arg1 = (wxWindow *) 0 ;
38602 bool result;
38603 void *argp1 = 0 ;
38604 int res1 = 0 ;
38605 PyObject *swig_obj[1] ;
38606
38607 if (!args) SWIG_fail;
38608 swig_obj[0] = args;
38609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38610 if (!SWIG_IsOK(res1)) {
38611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38612 }
38613 arg1 = reinterpret_cast< wxWindow * >(argp1);
38614 {
38615 PyThreadState* __tstate = wxPyBeginAllowThreads();
38616 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38617 wxPyEndAllowThreads(__tstate);
38618 if (PyErr_Occurred()) SWIG_fail;
38619 }
38620 {
38621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38622 }
38623 return resultobj;
38624 fail:
38625 return NULL;
38626 }
38627
38628
38629 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38630 PyObject *resultobj = 0;
38631 wxWindow *arg1 = (wxWindow *) 0 ;
38632 bool result;
38633 void *argp1 = 0 ;
38634 int res1 = 0 ;
38635 PyObject *swig_obj[1] ;
38636
38637 if (!args) SWIG_fail;
38638 swig_obj[0] = args;
38639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38640 if (!SWIG_IsOK(res1)) {
38641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38642 }
38643 arg1 = reinterpret_cast< wxWindow * >(argp1);
38644 {
38645 PyThreadState* __tstate = wxPyBeginAllowThreads();
38646 result = (bool)(arg1)->Layout();
38647 wxPyEndAllowThreads(__tstate);
38648 if (PyErr_Occurred()) SWIG_fail;
38649 }
38650 {
38651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38652 }
38653 return resultobj;
38654 fail:
38655 return NULL;
38656 }
38657
38658
38659 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38660 PyObject *resultobj = 0;
38661 wxWindow *arg1 = (wxWindow *) 0 ;
38662 wxSizer *arg2 = (wxSizer *) 0 ;
38663 bool arg3 = (bool) true ;
38664 void *argp1 = 0 ;
38665 int res1 = 0 ;
38666 int res2 = 0 ;
38667 bool val3 ;
38668 int ecode3 = 0 ;
38669 PyObject * obj0 = 0 ;
38670 PyObject * obj1 = 0 ;
38671 PyObject * obj2 = 0 ;
38672 char * kwnames[] = {
38673 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38674 };
38675
38676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38678 if (!SWIG_IsOK(res1)) {
38679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38680 }
38681 arg1 = reinterpret_cast< wxWindow * >(argp1);
38682 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38683 if (!SWIG_IsOK(res2)) {
38684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38685 }
38686 if (obj2) {
38687 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38688 if (!SWIG_IsOK(ecode3)) {
38689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38690 }
38691 arg3 = static_cast< bool >(val3);
38692 }
38693 {
38694 PyThreadState* __tstate = wxPyBeginAllowThreads();
38695 (arg1)->SetSizer(arg2,arg3);
38696 wxPyEndAllowThreads(__tstate);
38697 if (PyErr_Occurred()) SWIG_fail;
38698 }
38699 resultobj = SWIG_Py_Void();
38700 return resultobj;
38701 fail:
38702 return NULL;
38703 }
38704
38705
38706 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38707 PyObject *resultobj = 0;
38708 wxWindow *arg1 = (wxWindow *) 0 ;
38709 wxSizer *arg2 = (wxSizer *) 0 ;
38710 bool arg3 = (bool) true ;
38711 void *argp1 = 0 ;
38712 int res1 = 0 ;
38713 int res2 = 0 ;
38714 bool val3 ;
38715 int ecode3 = 0 ;
38716 PyObject * obj0 = 0 ;
38717 PyObject * obj1 = 0 ;
38718 PyObject * obj2 = 0 ;
38719 char * kwnames[] = {
38720 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38721 };
38722
38723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38725 if (!SWIG_IsOK(res1)) {
38726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38727 }
38728 arg1 = reinterpret_cast< wxWindow * >(argp1);
38729 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38730 if (!SWIG_IsOK(res2)) {
38731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38732 }
38733 if (obj2) {
38734 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38735 if (!SWIG_IsOK(ecode3)) {
38736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38737 }
38738 arg3 = static_cast< bool >(val3);
38739 }
38740 {
38741 PyThreadState* __tstate = wxPyBeginAllowThreads();
38742 (arg1)->SetSizerAndFit(arg2,arg3);
38743 wxPyEndAllowThreads(__tstate);
38744 if (PyErr_Occurred()) SWIG_fail;
38745 }
38746 resultobj = SWIG_Py_Void();
38747 return resultobj;
38748 fail:
38749 return NULL;
38750 }
38751
38752
38753 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38754 PyObject *resultobj = 0;
38755 wxWindow *arg1 = (wxWindow *) 0 ;
38756 wxSizer *result = 0 ;
38757 void *argp1 = 0 ;
38758 int res1 = 0 ;
38759 PyObject *swig_obj[1] ;
38760
38761 if (!args) SWIG_fail;
38762 swig_obj[0] = args;
38763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38764 if (!SWIG_IsOK(res1)) {
38765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38766 }
38767 arg1 = reinterpret_cast< wxWindow * >(argp1);
38768 {
38769 PyThreadState* __tstate = wxPyBeginAllowThreads();
38770 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38771 wxPyEndAllowThreads(__tstate);
38772 if (PyErr_Occurred()) SWIG_fail;
38773 }
38774 {
38775 resultobj = wxPyMake_wxObject(result, (bool)0);
38776 }
38777 return resultobj;
38778 fail:
38779 return NULL;
38780 }
38781
38782
38783 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38784 PyObject *resultobj = 0;
38785 wxWindow *arg1 = (wxWindow *) 0 ;
38786 wxSizer *arg2 = (wxSizer *) 0 ;
38787 void *argp1 = 0 ;
38788 int res1 = 0 ;
38789 void *argp2 = 0 ;
38790 int res2 = 0 ;
38791 PyObject * obj0 = 0 ;
38792 PyObject * obj1 = 0 ;
38793 char * kwnames[] = {
38794 (char *) "self",(char *) "sizer", NULL
38795 };
38796
38797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38799 if (!SWIG_IsOK(res1)) {
38800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38801 }
38802 arg1 = reinterpret_cast< wxWindow * >(argp1);
38803 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38804 if (!SWIG_IsOK(res2)) {
38805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38806 }
38807 arg2 = reinterpret_cast< wxSizer * >(argp2);
38808 {
38809 PyThreadState* __tstate = wxPyBeginAllowThreads();
38810 (arg1)->SetContainingSizer(arg2);
38811 wxPyEndAllowThreads(__tstate);
38812 if (PyErr_Occurred()) SWIG_fail;
38813 }
38814 resultobj = SWIG_Py_Void();
38815 return resultobj;
38816 fail:
38817 return NULL;
38818 }
38819
38820
38821 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38822 PyObject *resultobj = 0;
38823 wxWindow *arg1 = (wxWindow *) 0 ;
38824 wxSizer *result = 0 ;
38825 void *argp1 = 0 ;
38826 int res1 = 0 ;
38827 PyObject *swig_obj[1] ;
38828
38829 if (!args) SWIG_fail;
38830 swig_obj[0] = args;
38831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38832 if (!SWIG_IsOK(res1)) {
38833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38834 }
38835 arg1 = reinterpret_cast< wxWindow * >(argp1);
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38839 wxPyEndAllowThreads(__tstate);
38840 if (PyErr_Occurred()) SWIG_fail;
38841 }
38842 {
38843 resultobj = wxPyMake_wxObject(result, (bool)0);
38844 }
38845 return resultobj;
38846 fail:
38847 return NULL;
38848 }
38849
38850
38851 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38852 PyObject *resultobj = 0;
38853 wxWindow *arg1 = (wxWindow *) 0 ;
38854 void *argp1 = 0 ;
38855 int res1 = 0 ;
38856 PyObject *swig_obj[1] ;
38857
38858 if (!args) SWIG_fail;
38859 swig_obj[0] = args;
38860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38861 if (!SWIG_IsOK(res1)) {
38862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38863 }
38864 arg1 = reinterpret_cast< wxWindow * >(argp1);
38865 {
38866 PyThreadState* __tstate = wxPyBeginAllowThreads();
38867 (arg1)->InheritAttributes();
38868 wxPyEndAllowThreads(__tstate);
38869 if (PyErr_Occurred()) SWIG_fail;
38870 }
38871 resultobj = SWIG_Py_Void();
38872 return resultobj;
38873 fail:
38874 return NULL;
38875 }
38876
38877
38878 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38879 PyObject *resultobj = 0;
38880 wxWindow *arg1 = (wxWindow *) 0 ;
38881 bool result;
38882 void *argp1 = 0 ;
38883 int res1 = 0 ;
38884 PyObject *swig_obj[1] ;
38885
38886 if (!args) SWIG_fail;
38887 swig_obj[0] = args;
38888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38889 if (!SWIG_IsOK(res1)) {
38890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38891 }
38892 arg1 = reinterpret_cast< wxWindow * >(argp1);
38893 {
38894 PyThreadState* __tstate = wxPyBeginAllowThreads();
38895 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38896 wxPyEndAllowThreads(__tstate);
38897 if (PyErr_Occurred()) SWIG_fail;
38898 }
38899 {
38900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38901 }
38902 return resultobj;
38903 fail:
38904 return NULL;
38905 }
38906
38907
38908 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38909 PyObject *resultobj = 0;
38910 wxWindow *arg1 = (wxWindow *) 0 ;
38911 bool result;
38912 void *argp1 = 0 ;
38913 int res1 = 0 ;
38914 PyObject *swig_obj[1] ;
38915
38916 if (!args) SWIG_fail;
38917 swig_obj[0] = args;
38918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38919 if (!SWIG_IsOK(res1)) {
38920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38921 }
38922 arg1 = reinterpret_cast< wxWindow * >(argp1);
38923 {
38924 PyThreadState* __tstate = wxPyBeginAllowThreads();
38925 result = (bool)(arg1)->CanSetTransparent();
38926 wxPyEndAllowThreads(__tstate);
38927 if (PyErr_Occurred()) SWIG_fail;
38928 }
38929 {
38930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38931 }
38932 return resultobj;
38933 fail:
38934 return NULL;
38935 }
38936
38937
38938 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38939 PyObject *resultobj = 0;
38940 wxWindow *arg1 = (wxWindow *) 0 ;
38941 byte arg2 ;
38942 bool result;
38943 void *argp1 = 0 ;
38944 int res1 = 0 ;
38945 unsigned char val2 ;
38946 int ecode2 = 0 ;
38947 PyObject * obj0 = 0 ;
38948 PyObject * obj1 = 0 ;
38949 char * kwnames[] = {
38950 (char *) "self",(char *) "alpha", NULL
38951 };
38952
38953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38955 if (!SWIG_IsOK(res1)) {
38956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38957 }
38958 arg1 = reinterpret_cast< wxWindow * >(argp1);
38959 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38960 if (!SWIG_IsOK(ecode2)) {
38961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38962 }
38963 arg2 = static_cast< byte >(val2);
38964 {
38965 PyThreadState* __tstate = wxPyBeginAllowThreads();
38966 result = (bool)(arg1)->SetTransparent(arg2);
38967 wxPyEndAllowThreads(__tstate);
38968 if (PyErr_Occurred()) SWIG_fail;
38969 }
38970 {
38971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38972 }
38973 return resultobj;
38974 fail:
38975 return NULL;
38976 }
38977
38978
38979 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38980 PyObject *obj;
38981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38982 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38983 return SWIG_Py_Void();
38984 }
38985
38986 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38987 return SWIG_Python_InitShadowInstance(args);
38988 }
38989
38990 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38991 PyObject *resultobj = 0;
38992 long arg1 ;
38993 wxWindow *arg2 = (wxWindow *) NULL ;
38994 wxWindow *result = 0 ;
38995 long val1 ;
38996 int ecode1 = 0 ;
38997 void *argp2 = 0 ;
38998 int res2 = 0 ;
38999 PyObject * obj0 = 0 ;
39000 PyObject * obj1 = 0 ;
39001 char * kwnames[] = {
39002 (char *) "id",(char *) "parent", NULL
39003 };
39004
39005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
39006 ecode1 = SWIG_AsVal_long(obj0, &val1);
39007 if (!SWIG_IsOK(ecode1)) {
39008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
39009 }
39010 arg1 = static_cast< long >(val1);
39011 if (obj1) {
39012 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39013 if (!SWIG_IsOK(res2)) {
39014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
39015 }
39016 arg2 = reinterpret_cast< wxWindow * >(argp2);
39017 }
39018 {
39019 if (!wxPyCheckForApp()) SWIG_fail;
39020 PyThreadState* __tstate = wxPyBeginAllowThreads();
39021 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
39022 wxPyEndAllowThreads(__tstate);
39023 if (PyErr_Occurred()) SWIG_fail;
39024 }
39025 {
39026 resultobj = wxPyMake_wxObject(result, 0);
39027 }
39028 return resultobj;
39029 fail:
39030 return NULL;
39031 }
39032
39033
39034 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39035 PyObject *resultobj = 0;
39036 wxString *arg1 = 0 ;
39037 wxWindow *arg2 = (wxWindow *) NULL ;
39038 wxWindow *result = 0 ;
39039 bool temp1 = false ;
39040 void *argp2 = 0 ;
39041 int res2 = 0 ;
39042 PyObject * obj0 = 0 ;
39043 PyObject * obj1 = 0 ;
39044 char * kwnames[] = {
39045 (char *) "name",(char *) "parent", NULL
39046 };
39047
39048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
39049 {
39050 arg1 = wxString_in_helper(obj0);
39051 if (arg1 == NULL) SWIG_fail;
39052 temp1 = true;
39053 }
39054 if (obj1) {
39055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39056 if (!SWIG_IsOK(res2)) {
39057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
39058 }
39059 arg2 = reinterpret_cast< wxWindow * >(argp2);
39060 }
39061 {
39062 if (!wxPyCheckForApp()) SWIG_fail;
39063 PyThreadState* __tstate = wxPyBeginAllowThreads();
39064 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
39065 wxPyEndAllowThreads(__tstate);
39066 if (PyErr_Occurred()) SWIG_fail;
39067 }
39068 {
39069 resultobj = wxPyMake_wxObject(result, 0);
39070 }
39071 {
39072 if (temp1)
39073 delete arg1;
39074 }
39075 return resultobj;
39076 fail:
39077 {
39078 if (temp1)
39079 delete arg1;
39080 }
39081 return NULL;
39082 }
39083
39084
39085 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39086 PyObject *resultobj = 0;
39087 wxString *arg1 = 0 ;
39088 wxWindow *arg2 = (wxWindow *) NULL ;
39089 wxWindow *result = 0 ;
39090 bool temp1 = false ;
39091 void *argp2 = 0 ;
39092 int res2 = 0 ;
39093 PyObject * obj0 = 0 ;
39094 PyObject * obj1 = 0 ;
39095 char * kwnames[] = {
39096 (char *) "label",(char *) "parent", NULL
39097 };
39098
39099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39100 {
39101 arg1 = wxString_in_helper(obj0);
39102 if (arg1 == NULL) SWIG_fail;
39103 temp1 = true;
39104 }
39105 if (obj1) {
39106 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39107 if (!SWIG_IsOK(res2)) {
39108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
39109 }
39110 arg2 = reinterpret_cast< wxWindow * >(argp2);
39111 }
39112 {
39113 if (!wxPyCheckForApp()) SWIG_fail;
39114 PyThreadState* __tstate = wxPyBeginAllowThreads();
39115 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
39116 wxPyEndAllowThreads(__tstate);
39117 if (PyErr_Occurred()) SWIG_fail;
39118 }
39119 {
39120 resultobj = wxPyMake_wxObject(result, 0);
39121 }
39122 {
39123 if (temp1)
39124 delete arg1;
39125 }
39126 return resultobj;
39127 fail:
39128 {
39129 if (temp1)
39130 delete arg1;
39131 }
39132 return NULL;
39133 }
39134
39135
39136 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39137 PyObject *resultobj = 0;
39138 wxWindow *arg1 = (wxWindow *) 0 ;
39139 unsigned long arg2 ;
39140 wxWindow *result = 0 ;
39141 void *argp1 = 0 ;
39142 int res1 = 0 ;
39143 unsigned long val2 ;
39144 int ecode2 = 0 ;
39145 PyObject * obj0 = 0 ;
39146 PyObject * obj1 = 0 ;
39147 char * kwnames[] = {
39148 (char *) "parent",(char *) "_hWnd", NULL
39149 };
39150
39151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
39152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39153 if (!SWIG_IsOK(res1)) {
39154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
39155 }
39156 arg1 = reinterpret_cast< wxWindow * >(argp1);
39157 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
39158 if (!SWIG_IsOK(ecode2)) {
39159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
39160 }
39161 arg2 = static_cast< unsigned long >(val2);
39162 {
39163 PyThreadState* __tstate = wxPyBeginAllowThreads();
39164 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
39165 wxPyEndAllowThreads(__tstate);
39166 if (PyErr_Occurred()) SWIG_fail;
39167 }
39168 {
39169 resultobj = wxPyMake_wxObject(result, 0);
39170 }
39171 return resultobj;
39172 fail:
39173 return NULL;
39174 }
39175
39176
39177 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39178 PyObject *resultobj = 0;
39179 PyObject *result = 0 ;
39180
39181 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39182 {
39183 PyThreadState* __tstate = wxPyBeginAllowThreads();
39184 result = (PyObject *)GetTopLevelWindows();
39185 wxPyEndAllowThreads(__tstate);
39186 if (PyErr_Occurred()) SWIG_fail;
39187 }
39188 resultobj = result;
39189 return resultobj;
39190 fail:
39191 return NULL;
39192 }
39193
39194
39195 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39196 PyObject *resultobj = 0;
39197 wxValidator *result = 0 ;
39198
39199 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39200 {
39201 PyThreadState* __tstate = wxPyBeginAllowThreads();
39202 result = (wxValidator *)new wxValidator();
39203 wxPyEndAllowThreads(__tstate);
39204 if (PyErr_Occurred()) SWIG_fail;
39205 }
39206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39207 return resultobj;
39208 fail:
39209 return NULL;
39210 }
39211
39212
39213 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39214 PyObject *resultobj = 0;
39215 wxValidator *arg1 = (wxValidator *) 0 ;
39216 wxValidator *result = 0 ;
39217 void *argp1 = 0 ;
39218 int res1 = 0 ;
39219 PyObject *swig_obj[1] ;
39220
39221 if (!args) SWIG_fail;
39222 swig_obj[0] = args;
39223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39224 if (!SWIG_IsOK(res1)) {
39225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39226 }
39227 arg1 = reinterpret_cast< wxValidator * >(argp1);
39228 {
39229 PyThreadState* __tstate = wxPyBeginAllowThreads();
39230 result = (wxValidator *)(arg1)->Clone();
39231 wxPyEndAllowThreads(__tstate);
39232 if (PyErr_Occurred()) SWIG_fail;
39233 }
39234 {
39235 resultobj = wxPyMake_wxObject(result, 0);
39236 }
39237 return resultobj;
39238 fail:
39239 return NULL;
39240 }
39241
39242
39243 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39244 PyObject *resultobj = 0;
39245 wxValidator *arg1 = (wxValidator *) 0 ;
39246 wxWindow *arg2 = (wxWindow *) 0 ;
39247 bool result;
39248 void *argp1 = 0 ;
39249 int res1 = 0 ;
39250 void *argp2 = 0 ;
39251 int res2 = 0 ;
39252 PyObject * obj0 = 0 ;
39253 PyObject * obj1 = 0 ;
39254 char * kwnames[] = {
39255 (char *) "self",(char *) "parent", NULL
39256 };
39257
39258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39260 if (!SWIG_IsOK(res1)) {
39261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39262 }
39263 arg1 = reinterpret_cast< wxValidator * >(argp1);
39264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39265 if (!SWIG_IsOK(res2)) {
39266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39267 }
39268 arg2 = reinterpret_cast< wxWindow * >(argp2);
39269 {
39270 PyThreadState* __tstate = wxPyBeginAllowThreads();
39271 result = (bool)(arg1)->Validate(arg2);
39272 wxPyEndAllowThreads(__tstate);
39273 if (PyErr_Occurred()) SWIG_fail;
39274 }
39275 {
39276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39277 }
39278 return resultobj;
39279 fail:
39280 return NULL;
39281 }
39282
39283
39284 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39285 PyObject *resultobj = 0;
39286 wxValidator *arg1 = (wxValidator *) 0 ;
39287 bool result;
39288 void *argp1 = 0 ;
39289 int res1 = 0 ;
39290 PyObject *swig_obj[1] ;
39291
39292 if (!args) SWIG_fail;
39293 swig_obj[0] = args;
39294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39295 if (!SWIG_IsOK(res1)) {
39296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39297 }
39298 arg1 = reinterpret_cast< wxValidator * >(argp1);
39299 {
39300 PyThreadState* __tstate = wxPyBeginAllowThreads();
39301 result = (bool)(arg1)->TransferToWindow();
39302 wxPyEndAllowThreads(__tstate);
39303 if (PyErr_Occurred()) SWIG_fail;
39304 }
39305 {
39306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39307 }
39308 return resultobj;
39309 fail:
39310 return NULL;
39311 }
39312
39313
39314 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39315 PyObject *resultobj = 0;
39316 wxValidator *arg1 = (wxValidator *) 0 ;
39317 bool result;
39318 void *argp1 = 0 ;
39319 int res1 = 0 ;
39320 PyObject *swig_obj[1] ;
39321
39322 if (!args) SWIG_fail;
39323 swig_obj[0] = args;
39324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39325 if (!SWIG_IsOK(res1)) {
39326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39327 }
39328 arg1 = reinterpret_cast< wxValidator * >(argp1);
39329 {
39330 PyThreadState* __tstate = wxPyBeginAllowThreads();
39331 result = (bool)(arg1)->TransferFromWindow();
39332 wxPyEndAllowThreads(__tstate);
39333 if (PyErr_Occurred()) SWIG_fail;
39334 }
39335 {
39336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39337 }
39338 return resultobj;
39339 fail:
39340 return NULL;
39341 }
39342
39343
39344 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39345 PyObject *resultobj = 0;
39346 wxValidator *arg1 = (wxValidator *) 0 ;
39347 wxWindow *result = 0 ;
39348 void *argp1 = 0 ;
39349 int res1 = 0 ;
39350 PyObject *swig_obj[1] ;
39351
39352 if (!args) SWIG_fail;
39353 swig_obj[0] = args;
39354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39355 if (!SWIG_IsOK(res1)) {
39356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39357 }
39358 arg1 = reinterpret_cast< wxValidator * >(argp1);
39359 {
39360 PyThreadState* __tstate = wxPyBeginAllowThreads();
39361 result = (wxWindow *)(arg1)->GetWindow();
39362 wxPyEndAllowThreads(__tstate);
39363 if (PyErr_Occurred()) SWIG_fail;
39364 }
39365 {
39366 resultobj = wxPyMake_wxObject(result, 0);
39367 }
39368 return resultobj;
39369 fail:
39370 return NULL;
39371 }
39372
39373
39374 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39375 PyObject *resultobj = 0;
39376 wxValidator *arg1 = (wxValidator *) 0 ;
39377 wxWindow *arg2 = (wxWindow *) 0 ;
39378 void *argp1 = 0 ;
39379 int res1 = 0 ;
39380 void *argp2 = 0 ;
39381 int res2 = 0 ;
39382 PyObject * obj0 = 0 ;
39383 PyObject * obj1 = 0 ;
39384 char * kwnames[] = {
39385 (char *) "self",(char *) "window", NULL
39386 };
39387
39388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39390 if (!SWIG_IsOK(res1)) {
39391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39392 }
39393 arg1 = reinterpret_cast< wxValidator * >(argp1);
39394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39395 if (!SWIG_IsOK(res2)) {
39396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39397 }
39398 arg2 = reinterpret_cast< wxWindow * >(argp2);
39399 {
39400 PyThreadState* __tstate = wxPyBeginAllowThreads();
39401 (arg1)->SetWindow(arg2);
39402 wxPyEndAllowThreads(__tstate);
39403 if (PyErr_Occurred()) SWIG_fail;
39404 }
39405 resultobj = SWIG_Py_Void();
39406 return resultobj;
39407 fail:
39408 return NULL;
39409 }
39410
39411
39412 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39413 PyObject *resultobj = 0;
39414 bool result;
39415
39416 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39417 {
39418 PyThreadState* __tstate = wxPyBeginAllowThreads();
39419 result = (bool)wxValidator::IsSilent();
39420 wxPyEndAllowThreads(__tstate);
39421 if (PyErr_Occurred()) SWIG_fail;
39422 }
39423 {
39424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39425 }
39426 return resultobj;
39427 fail:
39428 return NULL;
39429 }
39430
39431
39432 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39433 PyObject *resultobj = 0;
39434 int arg1 = (int) true ;
39435 int val1 ;
39436 int ecode1 = 0 ;
39437 PyObject * obj0 = 0 ;
39438 char * kwnames[] = {
39439 (char *) "doIt", NULL
39440 };
39441
39442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39443 if (obj0) {
39444 ecode1 = SWIG_AsVal_int(obj0, &val1);
39445 if (!SWIG_IsOK(ecode1)) {
39446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39447 }
39448 arg1 = static_cast< int >(val1);
39449 }
39450 {
39451 PyThreadState* __tstate = wxPyBeginAllowThreads();
39452 wxValidator::SetBellOnError(arg1);
39453 wxPyEndAllowThreads(__tstate);
39454 if (PyErr_Occurred()) SWIG_fail;
39455 }
39456 resultobj = SWIG_Py_Void();
39457 return resultobj;
39458 fail:
39459 return NULL;
39460 }
39461
39462
39463 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39464 PyObject *obj;
39465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39466 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39467 return SWIG_Py_Void();
39468 }
39469
39470 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39471 return SWIG_Python_InitShadowInstance(args);
39472 }
39473
39474 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39475 PyObject *resultobj = 0;
39476 wxPyValidator *result = 0 ;
39477
39478 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39479 {
39480 PyThreadState* __tstate = wxPyBeginAllowThreads();
39481 result = (wxPyValidator *)new wxPyValidator();
39482 wxPyEndAllowThreads(__tstate);
39483 if (PyErr_Occurred()) SWIG_fail;
39484 }
39485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39486 return resultobj;
39487 fail:
39488 return NULL;
39489 }
39490
39491
39492 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39493 PyObject *resultobj = 0;
39494 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39495 PyObject *arg2 = (PyObject *) 0 ;
39496 PyObject *arg3 = (PyObject *) 0 ;
39497 int arg4 = (int) true ;
39498 void *argp1 = 0 ;
39499 int res1 = 0 ;
39500 int val4 ;
39501 int ecode4 = 0 ;
39502 PyObject * obj0 = 0 ;
39503 PyObject * obj1 = 0 ;
39504 PyObject * obj2 = 0 ;
39505 PyObject * obj3 = 0 ;
39506 char * kwnames[] = {
39507 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39508 };
39509
39510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39512 if (!SWIG_IsOK(res1)) {
39513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39514 }
39515 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39516 arg2 = obj1;
39517 arg3 = obj2;
39518 if (obj3) {
39519 ecode4 = SWIG_AsVal_int(obj3, &val4);
39520 if (!SWIG_IsOK(ecode4)) {
39521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39522 }
39523 arg4 = static_cast< int >(val4);
39524 }
39525 {
39526 PyThreadState* __tstate = wxPyBeginAllowThreads();
39527 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39528 wxPyEndAllowThreads(__tstate);
39529 if (PyErr_Occurred()) SWIG_fail;
39530 }
39531 resultobj = SWIG_Py_Void();
39532 return resultobj;
39533 fail:
39534 return NULL;
39535 }
39536
39537
39538 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39539 PyObject *obj;
39540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39541 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39542 return SWIG_Py_Void();
39543 }
39544
39545 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39546 return SWIG_Python_InitShadowInstance(args);
39547 }
39548
39549 SWIGINTERN int DefaultValidator_set(PyObject *) {
39550 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39551 return 1;
39552 }
39553
39554
39555 SWIGINTERN PyObject *DefaultValidator_get(void) {
39556 PyObject *pyobj = 0;
39557
39558 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39559 return pyobj;
39560 }
39561
39562
39563 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39564 PyObject *resultobj = 0;
39565 wxString const &arg1_defvalue = wxPyEmptyString ;
39566 wxString *arg1 = (wxString *) &arg1_defvalue ;
39567 long arg2 = (long) 0 ;
39568 wxMenu *result = 0 ;
39569 bool temp1 = false ;
39570 long val2 ;
39571 int ecode2 = 0 ;
39572 PyObject * obj0 = 0 ;
39573 PyObject * obj1 = 0 ;
39574 char * kwnames[] = {
39575 (char *) "title",(char *) "style", NULL
39576 };
39577
39578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39579 if (obj0) {
39580 {
39581 arg1 = wxString_in_helper(obj0);
39582 if (arg1 == NULL) SWIG_fail;
39583 temp1 = true;
39584 }
39585 }
39586 if (obj1) {
39587 ecode2 = SWIG_AsVal_long(obj1, &val2);
39588 if (!SWIG_IsOK(ecode2)) {
39589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39590 }
39591 arg2 = static_cast< long >(val2);
39592 }
39593 {
39594 if (!wxPyCheckForApp()) SWIG_fail;
39595 PyThreadState* __tstate = wxPyBeginAllowThreads();
39596 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39597 wxPyEndAllowThreads(__tstate);
39598 if (PyErr_Occurred()) SWIG_fail;
39599 }
39600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39601 {
39602 if (temp1)
39603 delete arg1;
39604 }
39605 return resultobj;
39606 fail:
39607 {
39608 if (temp1)
39609 delete arg1;
39610 }
39611 return NULL;
39612 }
39613
39614
39615 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39616 PyObject *resultobj = 0;
39617 wxMenu *arg1 = (wxMenu *) 0 ;
39618 int arg2 ;
39619 wxString const &arg3_defvalue = wxPyEmptyString ;
39620 wxString *arg3 = (wxString *) &arg3_defvalue ;
39621 wxString const &arg4_defvalue = wxPyEmptyString ;
39622 wxString *arg4 = (wxString *) &arg4_defvalue ;
39623 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39624 wxMenuItem *result = 0 ;
39625 void *argp1 = 0 ;
39626 int res1 = 0 ;
39627 int val2 ;
39628 int ecode2 = 0 ;
39629 bool temp3 = false ;
39630 bool temp4 = false ;
39631 int val5 ;
39632 int ecode5 = 0 ;
39633 PyObject * obj0 = 0 ;
39634 PyObject * obj1 = 0 ;
39635 PyObject * obj2 = 0 ;
39636 PyObject * obj3 = 0 ;
39637 PyObject * obj4 = 0 ;
39638 char * kwnames[] = {
39639 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39640 };
39641
39642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39644 if (!SWIG_IsOK(res1)) {
39645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39646 }
39647 arg1 = reinterpret_cast< wxMenu * >(argp1);
39648 ecode2 = SWIG_AsVal_int(obj1, &val2);
39649 if (!SWIG_IsOK(ecode2)) {
39650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39651 }
39652 arg2 = static_cast< int >(val2);
39653 if (obj2) {
39654 {
39655 arg3 = wxString_in_helper(obj2);
39656 if (arg3 == NULL) SWIG_fail;
39657 temp3 = true;
39658 }
39659 }
39660 if (obj3) {
39661 {
39662 arg4 = wxString_in_helper(obj3);
39663 if (arg4 == NULL) SWIG_fail;
39664 temp4 = true;
39665 }
39666 }
39667 if (obj4) {
39668 ecode5 = SWIG_AsVal_int(obj4, &val5);
39669 if (!SWIG_IsOK(ecode5)) {
39670 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39671 }
39672 arg5 = static_cast< wxItemKind >(val5);
39673 }
39674 {
39675 PyThreadState* __tstate = wxPyBeginAllowThreads();
39676 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39677 wxPyEndAllowThreads(__tstate);
39678 if (PyErr_Occurred()) SWIG_fail;
39679 }
39680 {
39681 resultobj = wxPyMake_wxObject(result, (bool)0);
39682 }
39683 {
39684 if (temp3)
39685 delete arg3;
39686 }
39687 {
39688 if (temp4)
39689 delete arg4;
39690 }
39691 return resultobj;
39692 fail:
39693 {
39694 if (temp3)
39695 delete arg3;
39696 }
39697 {
39698 if (temp4)
39699 delete arg4;
39700 }
39701 return NULL;
39702 }
39703
39704
39705 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39706 PyObject *resultobj = 0;
39707 wxMenu *arg1 = (wxMenu *) 0 ;
39708 wxMenuItem *result = 0 ;
39709 void *argp1 = 0 ;
39710 int res1 = 0 ;
39711 PyObject *swig_obj[1] ;
39712
39713 if (!args) SWIG_fail;
39714 swig_obj[0] = args;
39715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39716 if (!SWIG_IsOK(res1)) {
39717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39718 }
39719 arg1 = reinterpret_cast< wxMenu * >(argp1);
39720 {
39721 PyThreadState* __tstate = wxPyBeginAllowThreads();
39722 result = (wxMenuItem *)(arg1)->AppendSeparator();
39723 wxPyEndAllowThreads(__tstate);
39724 if (PyErr_Occurred()) SWIG_fail;
39725 }
39726 {
39727 resultobj = wxPyMake_wxObject(result, (bool)0);
39728 }
39729 return resultobj;
39730 fail:
39731 return NULL;
39732 }
39733
39734
39735 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39736 PyObject *resultobj = 0;
39737 wxMenu *arg1 = (wxMenu *) 0 ;
39738 int arg2 ;
39739 wxString *arg3 = 0 ;
39740 wxString const &arg4_defvalue = wxPyEmptyString ;
39741 wxString *arg4 = (wxString *) &arg4_defvalue ;
39742 wxMenuItem *result = 0 ;
39743 void *argp1 = 0 ;
39744 int res1 = 0 ;
39745 int val2 ;
39746 int ecode2 = 0 ;
39747 bool temp3 = false ;
39748 bool temp4 = false ;
39749 PyObject * obj0 = 0 ;
39750 PyObject * obj1 = 0 ;
39751 PyObject * obj2 = 0 ;
39752 PyObject * obj3 = 0 ;
39753 char * kwnames[] = {
39754 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39755 };
39756
39757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39759 if (!SWIG_IsOK(res1)) {
39760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39761 }
39762 arg1 = reinterpret_cast< wxMenu * >(argp1);
39763 ecode2 = SWIG_AsVal_int(obj1, &val2);
39764 if (!SWIG_IsOK(ecode2)) {
39765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39766 }
39767 arg2 = static_cast< int >(val2);
39768 {
39769 arg3 = wxString_in_helper(obj2);
39770 if (arg3 == NULL) SWIG_fail;
39771 temp3 = true;
39772 }
39773 if (obj3) {
39774 {
39775 arg4 = wxString_in_helper(obj3);
39776 if (arg4 == NULL) SWIG_fail;
39777 temp4 = true;
39778 }
39779 }
39780 {
39781 PyThreadState* __tstate = wxPyBeginAllowThreads();
39782 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39783 wxPyEndAllowThreads(__tstate);
39784 if (PyErr_Occurred()) SWIG_fail;
39785 }
39786 {
39787 resultobj = wxPyMake_wxObject(result, (bool)0);
39788 }
39789 {
39790 if (temp3)
39791 delete arg3;
39792 }
39793 {
39794 if (temp4)
39795 delete arg4;
39796 }
39797 return resultobj;
39798 fail:
39799 {
39800 if (temp3)
39801 delete arg3;
39802 }
39803 {
39804 if (temp4)
39805 delete arg4;
39806 }
39807 return NULL;
39808 }
39809
39810
39811 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39812 PyObject *resultobj = 0;
39813 wxMenu *arg1 = (wxMenu *) 0 ;
39814 int arg2 ;
39815 wxString *arg3 = 0 ;
39816 wxString const &arg4_defvalue = wxPyEmptyString ;
39817 wxString *arg4 = (wxString *) &arg4_defvalue ;
39818 wxMenuItem *result = 0 ;
39819 void *argp1 = 0 ;
39820 int res1 = 0 ;
39821 int val2 ;
39822 int ecode2 = 0 ;
39823 bool temp3 = false ;
39824 bool temp4 = false ;
39825 PyObject * obj0 = 0 ;
39826 PyObject * obj1 = 0 ;
39827 PyObject * obj2 = 0 ;
39828 PyObject * obj3 = 0 ;
39829 char * kwnames[] = {
39830 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39831 };
39832
39833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39835 if (!SWIG_IsOK(res1)) {
39836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39837 }
39838 arg1 = reinterpret_cast< wxMenu * >(argp1);
39839 ecode2 = SWIG_AsVal_int(obj1, &val2);
39840 if (!SWIG_IsOK(ecode2)) {
39841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39842 }
39843 arg2 = static_cast< int >(val2);
39844 {
39845 arg3 = wxString_in_helper(obj2);
39846 if (arg3 == NULL) SWIG_fail;
39847 temp3 = true;
39848 }
39849 if (obj3) {
39850 {
39851 arg4 = wxString_in_helper(obj3);
39852 if (arg4 == NULL) SWIG_fail;
39853 temp4 = true;
39854 }
39855 }
39856 {
39857 PyThreadState* __tstate = wxPyBeginAllowThreads();
39858 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39859 wxPyEndAllowThreads(__tstate);
39860 if (PyErr_Occurred()) SWIG_fail;
39861 }
39862 {
39863 resultobj = wxPyMake_wxObject(result, (bool)0);
39864 }
39865 {
39866 if (temp3)
39867 delete arg3;
39868 }
39869 {
39870 if (temp4)
39871 delete arg4;
39872 }
39873 return resultobj;
39874 fail:
39875 {
39876 if (temp3)
39877 delete arg3;
39878 }
39879 {
39880 if (temp4)
39881 delete arg4;
39882 }
39883 return NULL;
39884 }
39885
39886
39887 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39888 PyObject *resultobj = 0;
39889 wxMenu *arg1 = (wxMenu *) 0 ;
39890 int arg2 ;
39891 wxString *arg3 = 0 ;
39892 wxMenu *arg4 = (wxMenu *) 0 ;
39893 wxString const &arg5_defvalue = wxPyEmptyString ;
39894 wxString *arg5 = (wxString *) &arg5_defvalue ;
39895 wxMenuItem *result = 0 ;
39896 void *argp1 = 0 ;
39897 int res1 = 0 ;
39898 int val2 ;
39899 int ecode2 = 0 ;
39900 bool temp3 = false ;
39901 void *argp4 = 0 ;
39902 int res4 = 0 ;
39903 bool temp5 = false ;
39904 PyObject * obj0 = 0 ;
39905 PyObject * obj1 = 0 ;
39906 PyObject * obj2 = 0 ;
39907 PyObject * obj3 = 0 ;
39908 PyObject * obj4 = 0 ;
39909 char * kwnames[] = {
39910 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39911 };
39912
39913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39915 if (!SWIG_IsOK(res1)) {
39916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39917 }
39918 arg1 = reinterpret_cast< wxMenu * >(argp1);
39919 ecode2 = SWIG_AsVal_int(obj1, &val2);
39920 if (!SWIG_IsOK(ecode2)) {
39921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39922 }
39923 arg2 = static_cast< int >(val2);
39924 {
39925 arg3 = wxString_in_helper(obj2);
39926 if (arg3 == NULL) SWIG_fail;
39927 temp3 = true;
39928 }
39929 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39930 if (!SWIG_IsOK(res4)) {
39931 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39932 }
39933 arg4 = reinterpret_cast< wxMenu * >(argp4);
39934 if (obj4) {
39935 {
39936 arg5 = wxString_in_helper(obj4);
39937 if (arg5 == NULL) SWIG_fail;
39938 temp5 = true;
39939 }
39940 }
39941 {
39942 PyThreadState* __tstate = wxPyBeginAllowThreads();
39943 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39944 wxPyEndAllowThreads(__tstate);
39945 if (PyErr_Occurred()) SWIG_fail;
39946 }
39947 {
39948 resultobj = wxPyMake_wxObject(result, (bool)0);
39949 }
39950 {
39951 if (temp3)
39952 delete arg3;
39953 }
39954 {
39955 if (temp5)
39956 delete arg5;
39957 }
39958 return resultobj;
39959 fail:
39960 {
39961 if (temp3)
39962 delete arg3;
39963 }
39964 {
39965 if (temp5)
39966 delete arg5;
39967 }
39968 return NULL;
39969 }
39970
39971
39972 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39973 PyObject *resultobj = 0;
39974 wxMenu *arg1 = (wxMenu *) 0 ;
39975 wxMenu *arg2 = (wxMenu *) 0 ;
39976 wxString *arg3 = 0 ;
39977 wxString const &arg4_defvalue = wxPyEmptyString ;
39978 wxString *arg4 = (wxString *) &arg4_defvalue ;
39979 wxMenuItem *result = 0 ;
39980 void *argp1 = 0 ;
39981 int res1 = 0 ;
39982 void *argp2 = 0 ;
39983 int res2 = 0 ;
39984 bool temp3 = false ;
39985 bool temp4 = false ;
39986 PyObject * obj0 = 0 ;
39987 PyObject * obj1 = 0 ;
39988 PyObject * obj2 = 0 ;
39989 PyObject * obj3 = 0 ;
39990 char * kwnames[] = {
39991 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39992 };
39993
39994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39996 if (!SWIG_IsOK(res1)) {
39997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39998 }
39999 arg1 = reinterpret_cast< wxMenu * >(argp1);
40000 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40001 if (!SWIG_IsOK(res2)) {
40002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
40003 }
40004 arg2 = reinterpret_cast< wxMenu * >(argp2);
40005 {
40006 arg3 = wxString_in_helper(obj2);
40007 if (arg3 == NULL) SWIG_fail;
40008 temp3 = true;
40009 }
40010 if (obj3) {
40011 {
40012 arg4 = wxString_in_helper(obj3);
40013 if (arg4 == NULL) SWIG_fail;
40014 temp4 = true;
40015 }
40016 }
40017 {
40018 PyThreadState* __tstate = wxPyBeginAllowThreads();
40019 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40020 wxPyEndAllowThreads(__tstate);
40021 if (PyErr_Occurred()) SWIG_fail;
40022 }
40023 {
40024 resultobj = wxPyMake_wxObject(result, (bool)0);
40025 }
40026 {
40027 if (temp3)
40028 delete arg3;
40029 }
40030 {
40031 if (temp4)
40032 delete arg4;
40033 }
40034 return resultobj;
40035 fail:
40036 {
40037 if (temp3)
40038 delete arg3;
40039 }
40040 {
40041 if (temp4)
40042 delete arg4;
40043 }
40044 return NULL;
40045 }
40046
40047
40048 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40049 PyObject *resultobj = 0;
40050 wxMenu *arg1 = (wxMenu *) 0 ;
40051 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40052 wxMenuItem *result = 0 ;
40053 void *argp1 = 0 ;
40054 int res1 = 0 ;
40055 int res2 = 0 ;
40056 PyObject * obj0 = 0 ;
40057 PyObject * obj1 = 0 ;
40058 char * kwnames[] = {
40059 (char *) "self",(char *) "item", NULL
40060 };
40061
40062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
40063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40064 if (!SWIG_IsOK(res1)) {
40065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40066 }
40067 arg1 = reinterpret_cast< wxMenu * >(argp1);
40068 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40069 if (!SWIG_IsOK(res2)) {
40070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40071 }
40072 {
40073 PyThreadState* __tstate = wxPyBeginAllowThreads();
40074 result = (wxMenuItem *)(arg1)->Append(arg2);
40075 wxPyEndAllowThreads(__tstate);
40076 if (PyErr_Occurred()) SWIG_fail;
40077 }
40078 {
40079 resultobj = wxPyMake_wxObject(result, (bool)0);
40080 }
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj = 0;
40089 wxMenu *arg1 = (wxMenu *) 0 ;
40090 size_t arg2 ;
40091 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
40092 wxMenuItem *result = 0 ;
40093 void *argp1 = 0 ;
40094 int res1 = 0 ;
40095 size_t val2 ;
40096 int ecode2 = 0 ;
40097 int res3 = 0 ;
40098 PyObject * obj0 = 0 ;
40099 PyObject * obj1 = 0 ;
40100 PyObject * obj2 = 0 ;
40101 char * kwnames[] = {
40102 (char *) "self",(char *) "pos",(char *) "item", NULL
40103 };
40104
40105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40107 if (!SWIG_IsOK(res1)) {
40108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40109 }
40110 arg1 = reinterpret_cast< wxMenu * >(argp1);
40111 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40112 if (!SWIG_IsOK(ecode2)) {
40113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
40114 }
40115 arg2 = static_cast< size_t >(val2);
40116 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40117 if (!SWIG_IsOK(res3)) {
40118 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
40119 }
40120 {
40121 PyThreadState* __tstate = wxPyBeginAllowThreads();
40122 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
40123 wxPyEndAllowThreads(__tstate);
40124 if (PyErr_Occurred()) SWIG_fail;
40125 }
40126 {
40127 resultobj = wxPyMake_wxObject(result, (bool)0);
40128 }
40129 return resultobj;
40130 fail:
40131 return NULL;
40132 }
40133
40134
40135 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40136 PyObject *resultobj = 0;
40137 wxMenu *arg1 = (wxMenu *) 0 ;
40138 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40139 wxMenuItem *result = 0 ;
40140 void *argp1 = 0 ;
40141 int res1 = 0 ;
40142 int res2 = 0 ;
40143 PyObject * obj0 = 0 ;
40144 PyObject * obj1 = 0 ;
40145 char * kwnames[] = {
40146 (char *) "self",(char *) "item", NULL
40147 };
40148
40149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
40150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40151 if (!SWIG_IsOK(res1)) {
40152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40153 }
40154 arg1 = reinterpret_cast< wxMenu * >(argp1);
40155 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40156 if (!SWIG_IsOK(res2)) {
40157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40158 }
40159 {
40160 PyThreadState* __tstate = wxPyBeginAllowThreads();
40161 result = (wxMenuItem *)(arg1)->Prepend(arg2);
40162 wxPyEndAllowThreads(__tstate);
40163 if (PyErr_Occurred()) SWIG_fail;
40164 }
40165 {
40166 resultobj = wxPyMake_wxObject(result, (bool)0);
40167 }
40168 return resultobj;
40169 fail:
40170 return NULL;
40171 }
40172
40173
40174 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40175 PyObject *resultobj = 0;
40176 wxMenu *arg1 = (wxMenu *) 0 ;
40177 void *argp1 = 0 ;
40178 int res1 = 0 ;
40179 PyObject *swig_obj[1] ;
40180
40181 if (!args) SWIG_fail;
40182 swig_obj[0] = args;
40183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40184 if (!SWIG_IsOK(res1)) {
40185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40186 }
40187 arg1 = reinterpret_cast< wxMenu * >(argp1);
40188 {
40189 PyThreadState* __tstate = wxPyBeginAllowThreads();
40190 (arg1)->Break();
40191 wxPyEndAllowThreads(__tstate);
40192 if (PyErr_Occurred()) SWIG_fail;
40193 }
40194 resultobj = SWIG_Py_Void();
40195 return resultobj;
40196 fail:
40197 return NULL;
40198 }
40199
40200
40201 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40202 PyObject *resultobj = 0;
40203 wxMenu *arg1 = (wxMenu *) 0 ;
40204 size_t arg2 ;
40205 int arg3 ;
40206 wxString const &arg4_defvalue = wxPyEmptyString ;
40207 wxString *arg4 = (wxString *) &arg4_defvalue ;
40208 wxString const &arg5_defvalue = wxPyEmptyString ;
40209 wxString *arg5 = (wxString *) &arg5_defvalue ;
40210 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40211 wxMenuItem *result = 0 ;
40212 void *argp1 = 0 ;
40213 int res1 = 0 ;
40214 size_t val2 ;
40215 int ecode2 = 0 ;
40216 int val3 ;
40217 int ecode3 = 0 ;
40218 bool temp4 = false ;
40219 bool temp5 = false ;
40220 int val6 ;
40221 int ecode6 = 0 ;
40222 PyObject * obj0 = 0 ;
40223 PyObject * obj1 = 0 ;
40224 PyObject * obj2 = 0 ;
40225 PyObject * obj3 = 0 ;
40226 PyObject * obj4 = 0 ;
40227 PyObject * obj5 = 0 ;
40228 char * kwnames[] = {
40229 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40230 };
40231
40232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40234 if (!SWIG_IsOK(res1)) {
40235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40236 }
40237 arg1 = reinterpret_cast< wxMenu * >(argp1);
40238 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40239 if (!SWIG_IsOK(ecode2)) {
40240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40241 }
40242 arg2 = static_cast< size_t >(val2);
40243 ecode3 = SWIG_AsVal_int(obj2, &val3);
40244 if (!SWIG_IsOK(ecode3)) {
40245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40246 }
40247 arg3 = static_cast< int >(val3);
40248 if (obj3) {
40249 {
40250 arg4 = wxString_in_helper(obj3);
40251 if (arg4 == NULL) SWIG_fail;
40252 temp4 = true;
40253 }
40254 }
40255 if (obj4) {
40256 {
40257 arg5 = wxString_in_helper(obj4);
40258 if (arg5 == NULL) SWIG_fail;
40259 temp5 = true;
40260 }
40261 }
40262 if (obj5) {
40263 ecode6 = SWIG_AsVal_int(obj5, &val6);
40264 if (!SWIG_IsOK(ecode6)) {
40265 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40266 }
40267 arg6 = static_cast< wxItemKind >(val6);
40268 }
40269 {
40270 PyThreadState* __tstate = wxPyBeginAllowThreads();
40271 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40272 wxPyEndAllowThreads(__tstate);
40273 if (PyErr_Occurred()) SWIG_fail;
40274 }
40275 {
40276 resultobj = wxPyMake_wxObject(result, (bool)0);
40277 }
40278 {
40279 if (temp4)
40280 delete arg4;
40281 }
40282 {
40283 if (temp5)
40284 delete arg5;
40285 }
40286 return resultobj;
40287 fail:
40288 {
40289 if (temp4)
40290 delete arg4;
40291 }
40292 {
40293 if (temp5)
40294 delete arg5;
40295 }
40296 return NULL;
40297 }
40298
40299
40300 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40301 PyObject *resultobj = 0;
40302 wxMenu *arg1 = (wxMenu *) 0 ;
40303 size_t arg2 ;
40304 wxMenuItem *result = 0 ;
40305 void *argp1 = 0 ;
40306 int res1 = 0 ;
40307 size_t val2 ;
40308 int ecode2 = 0 ;
40309 PyObject * obj0 = 0 ;
40310 PyObject * obj1 = 0 ;
40311 char * kwnames[] = {
40312 (char *) "self",(char *) "pos", NULL
40313 };
40314
40315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40317 if (!SWIG_IsOK(res1)) {
40318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40319 }
40320 arg1 = reinterpret_cast< wxMenu * >(argp1);
40321 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40322 if (!SWIG_IsOK(ecode2)) {
40323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40324 }
40325 arg2 = static_cast< size_t >(val2);
40326 {
40327 PyThreadState* __tstate = wxPyBeginAllowThreads();
40328 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40329 wxPyEndAllowThreads(__tstate);
40330 if (PyErr_Occurred()) SWIG_fail;
40331 }
40332 {
40333 resultobj = wxPyMake_wxObject(result, (bool)0);
40334 }
40335 return resultobj;
40336 fail:
40337 return NULL;
40338 }
40339
40340
40341 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40342 PyObject *resultobj = 0;
40343 wxMenu *arg1 = (wxMenu *) 0 ;
40344 size_t arg2 ;
40345 int arg3 ;
40346 wxString *arg4 = 0 ;
40347 wxString const &arg5_defvalue = wxPyEmptyString ;
40348 wxString *arg5 = (wxString *) &arg5_defvalue ;
40349 wxMenuItem *result = 0 ;
40350 void *argp1 = 0 ;
40351 int res1 = 0 ;
40352 size_t val2 ;
40353 int ecode2 = 0 ;
40354 int val3 ;
40355 int ecode3 = 0 ;
40356 bool temp4 = false ;
40357 bool temp5 = false ;
40358 PyObject * obj0 = 0 ;
40359 PyObject * obj1 = 0 ;
40360 PyObject * obj2 = 0 ;
40361 PyObject * obj3 = 0 ;
40362 PyObject * obj4 = 0 ;
40363 char * kwnames[] = {
40364 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40365 };
40366
40367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40369 if (!SWIG_IsOK(res1)) {
40370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40371 }
40372 arg1 = reinterpret_cast< wxMenu * >(argp1);
40373 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40374 if (!SWIG_IsOK(ecode2)) {
40375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40376 }
40377 arg2 = static_cast< size_t >(val2);
40378 ecode3 = SWIG_AsVal_int(obj2, &val3);
40379 if (!SWIG_IsOK(ecode3)) {
40380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40381 }
40382 arg3 = static_cast< int >(val3);
40383 {
40384 arg4 = wxString_in_helper(obj3);
40385 if (arg4 == NULL) SWIG_fail;
40386 temp4 = true;
40387 }
40388 if (obj4) {
40389 {
40390 arg5 = wxString_in_helper(obj4);
40391 if (arg5 == NULL) SWIG_fail;
40392 temp5 = true;
40393 }
40394 }
40395 {
40396 PyThreadState* __tstate = wxPyBeginAllowThreads();
40397 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40398 wxPyEndAllowThreads(__tstate);
40399 if (PyErr_Occurred()) SWIG_fail;
40400 }
40401 {
40402 resultobj = wxPyMake_wxObject(result, (bool)0);
40403 }
40404 {
40405 if (temp4)
40406 delete arg4;
40407 }
40408 {
40409 if (temp5)
40410 delete arg5;
40411 }
40412 return resultobj;
40413 fail:
40414 {
40415 if (temp4)
40416 delete arg4;
40417 }
40418 {
40419 if (temp5)
40420 delete arg5;
40421 }
40422 return NULL;
40423 }
40424
40425
40426 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40427 PyObject *resultobj = 0;
40428 wxMenu *arg1 = (wxMenu *) 0 ;
40429 size_t arg2 ;
40430 int arg3 ;
40431 wxString *arg4 = 0 ;
40432 wxString const &arg5_defvalue = wxPyEmptyString ;
40433 wxString *arg5 = (wxString *) &arg5_defvalue ;
40434 wxMenuItem *result = 0 ;
40435 void *argp1 = 0 ;
40436 int res1 = 0 ;
40437 size_t val2 ;
40438 int ecode2 = 0 ;
40439 int val3 ;
40440 int ecode3 = 0 ;
40441 bool temp4 = false ;
40442 bool temp5 = false ;
40443 PyObject * obj0 = 0 ;
40444 PyObject * obj1 = 0 ;
40445 PyObject * obj2 = 0 ;
40446 PyObject * obj3 = 0 ;
40447 PyObject * obj4 = 0 ;
40448 char * kwnames[] = {
40449 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40450 };
40451
40452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40454 if (!SWIG_IsOK(res1)) {
40455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40456 }
40457 arg1 = reinterpret_cast< wxMenu * >(argp1);
40458 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40459 if (!SWIG_IsOK(ecode2)) {
40460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40461 }
40462 arg2 = static_cast< size_t >(val2);
40463 ecode3 = SWIG_AsVal_int(obj2, &val3);
40464 if (!SWIG_IsOK(ecode3)) {
40465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40466 }
40467 arg3 = static_cast< int >(val3);
40468 {
40469 arg4 = wxString_in_helper(obj3);
40470 if (arg4 == NULL) SWIG_fail;
40471 temp4 = true;
40472 }
40473 if (obj4) {
40474 {
40475 arg5 = wxString_in_helper(obj4);
40476 if (arg5 == NULL) SWIG_fail;
40477 temp5 = true;
40478 }
40479 }
40480 {
40481 PyThreadState* __tstate = wxPyBeginAllowThreads();
40482 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40483 wxPyEndAllowThreads(__tstate);
40484 if (PyErr_Occurred()) SWIG_fail;
40485 }
40486 {
40487 resultobj = wxPyMake_wxObject(result, (bool)0);
40488 }
40489 {
40490 if (temp4)
40491 delete arg4;
40492 }
40493 {
40494 if (temp5)
40495 delete arg5;
40496 }
40497 return resultobj;
40498 fail:
40499 {
40500 if (temp4)
40501 delete arg4;
40502 }
40503 {
40504 if (temp5)
40505 delete arg5;
40506 }
40507 return NULL;
40508 }
40509
40510
40511 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40512 PyObject *resultobj = 0;
40513 wxMenu *arg1 = (wxMenu *) 0 ;
40514 size_t arg2 ;
40515 int arg3 ;
40516 wxString *arg4 = 0 ;
40517 wxMenu *arg5 = (wxMenu *) 0 ;
40518 wxString const &arg6_defvalue = wxPyEmptyString ;
40519 wxString *arg6 = (wxString *) &arg6_defvalue ;
40520 wxMenuItem *result = 0 ;
40521 void *argp1 = 0 ;
40522 int res1 = 0 ;
40523 size_t val2 ;
40524 int ecode2 = 0 ;
40525 int val3 ;
40526 int ecode3 = 0 ;
40527 bool temp4 = false ;
40528 void *argp5 = 0 ;
40529 int res5 = 0 ;
40530 bool temp6 = false ;
40531 PyObject * obj0 = 0 ;
40532 PyObject * obj1 = 0 ;
40533 PyObject * obj2 = 0 ;
40534 PyObject * obj3 = 0 ;
40535 PyObject * obj4 = 0 ;
40536 PyObject * obj5 = 0 ;
40537 char * kwnames[] = {
40538 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40539 };
40540
40541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40543 if (!SWIG_IsOK(res1)) {
40544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40545 }
40546 arg1 = reinterpret_cast< wxMenu * >(argp1);
40547 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40548 if (!SWIG_IsOK(ecode2)) {
40549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40550 }
40551 arg2 = static_cast< size_t >(val2);
40552 ecode3 = SWIG_AsVal_int(obj2, &val3);
40553 if (!SWIG_IsOK(ecode3)) {
40554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40555 }
40556 arg3 = static_cast< int >(val3);
40557 {
40558 arg4 = wxString_in_helper(obj3);
40559 if (arg4 == NULL) SWIG_fail;
40560 temp4 = true;
40561 }
40562 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40563 if (!SWIG_IsOK(res5)) {
40564 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40565 }
40566 arg5 = reinterpret_cast< wxMenu * >(argp5);
40567 if (obj5) {
40568 {
40569 arg6 = wxString_in_helper(obj5);
40570 if (arg6 == NULL) SWIG_fail;
40571 temp6 = true;
40572 }
40573 }
40574 {
40575 PyThreadState* __tstate = wxPyBeginAllowThreads();
40576 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40577 wxPyEndAllowThreads(__tstate);
40578 if (PyErr_Occurred()) SWIG_fail;
40579 }
40580 {
40581 resultobj = wxPyMake_wxObject(result, (bool)0);
40582 }
40583 {
40584 if (temp4)
40585 delete arg4;
40586 }
40587 {
40588 if (temp6)
40589 delete arg6;
40590 }
40591 return resultobj;
40592 fail:
40593 {
40594 if (temp4)
40595 delete arg4;
40596 }
40597 {
40598 if (temp6)
40599 delete arg6;
40600 }
40601 return NULL;
40602 }
40603
40604
40605 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40606 PyObject *resultobj = 0;
40607 wxMenu *arg1 = (wxMenu *) 0 ;
40608 int arg2 ;
40609 wxString const &arg3_defvalue = wxPyEmptyString ;
40610 wxString *arg3 = (wxString *) &arg3_defvalue ;
40611 wxString const &arg4_defvalue = wxPyEmptyString ;
40612 wxString *arg4 = (wxString *) &arg4_defvalue ;
40613 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40614 wxMenuItem *result = 0 ;
40615 void *argp1 = 0 ;
40616 int res1 = 0 ;
40617 int val2 ;
40618 int ecode2 = 0 ;
40619 bool temp3 = false ;
40620 bool temp4 = false ;
40621 int val5 ;
40622 int ecode5 = 0 ;
40623 PyObject * obj0 = 0 ;
40624 PyObject * obj1 = 0 ;
40625 PyObject * obj2 = 0 ;
40626 PyObject * obj3 = 0 ;
40627 PyObject * obj4 = 0 ;
40628 char * kwnames[] = {
40629 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40630 };
40631
40632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40634 if (!SWIG_IsOK(res1)) {
40635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40636 }
40637 arg1 = reinterpret_cast< wxMenu * >(argp1);
40638 ecode2 = SWIG_AsVal_int(obj1, &val2);
40639 if (!SWIG_IsOK(ecode2)) {
40640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40641 }
40642 arg2 = static_cast< int >(val2);
40643 if (obj2) {
40644 {
40645 arg3 = wxString_in_helper(obj2);
40646 if (arg3 == NULL) SWIG_fail;
40647 temp3 = true;
40648 }
40649 }
40650 if (obj3) {
40651 {
40652 arg4 = wxString_in_helper(obj3);
40653 if (arg4 == NULL) SWIG_fail;
40654 temp4 = true;
40655 }
40656 }
40657 if (obj4) {
40658 ecode5 = SWIG_AsVal_int(obj4, &val5);
40659 if (!SWIG_IsOK(ecode5)) {
40660 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40661 }
40662 arg5 = static_cast< wxItemKind >(val5);
40663 }
40664 {
40665 PyThreadState* __tstate = wxPyBeginAllowThreads();
40666 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40667 wxPyEndAllowThreads(__tstate);
40668 if (PyErr_Occurred()) SWIG_fail;
40669 }
40670 {
40671 resultobj = wxPyMake_wxObject(result, (bool)0);
40672 }
40673 {
40674 if (temp3)
40675 delete arg3;
40676 }
40677 {
40678 if (temp4)
40679 delete arg4;
40680 }
40681 return resultobj;
40682 fail:
40683 {
40684 if (temp3)
40685 delete arg3;
40686 }
40687 {
40688 if (temp4)
40689 delete arg4;
40690 }
40691 return NULL;
40692 }
40693
40694
40695 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40696 PyObject *resultobj = 0;
40697 wxMenu *arg1 = (wxMenu *) 0 ;
40698 wxMenuItem *result = 0 ;
40699 void *argp1 = 0 ;
40700 int res1 = 0 ;
40701 PyObject *swig_obj[1] ;
40702
40703 if (!args) SWIG_fail;
40704 swig_obj[0] = args;
40705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40706 if (!SWIG_IsOK(res1)) {
40707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40708 }
40709 arg1 = reinterpret_cast< wxMenu * >(argp1);
40710 {
40711 PyThreadState* __tstate = wxPyBeginAllowThreads();
40712 result = (wxMenuItem *)(arg1)->PrependSeparator();
40713 wxPyEndAllowThreads(__tstate);
40714 if (PyErr_Occurred()) SWIG_fail;
40715 }
40716 {
40717 resultobj = wxPyMake_wxObject(result, (bool)0);
40718 }
40719 return resultobj;
40720 fail:
40721 return NULL;
40722 }
40723
40724
40725 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40726 PyObject *resultobj = 0;
40727 wxMenu *arg1 = (wxMenu *) 0 ;
40728 int arg2 ;
40729 wxString *arg3 = 0 ;
40730 wxString const &arg4_defvalue = wxPyEmptyString ;
40731 wxString *arg4 = (wxString *) &arg4_defvalue ;
40732 wxMenuItem *result = 0 ;
40733 void *argp1 = 0 ;
40734 int res1 = 0 ;
40735 int val2 ;
40736 int ecode2 = 0 ;
40737 bool temp3 = false ;
40738 bool temp4 = false ;
40739 PyObject * obj0 = 0 ;
40740 PyObject * obj1 = 0 ;
40741 PyObject * obj2 = 0 ;
40742 PyObject * obj3 = 0 ;
40743 char * kwnames[] = {
40744 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40745 };
40746
40747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40749 if (!SWIG_IsOK(res1)) {
40750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40751 }
40752 arg1 = reinterpret_cast< wxMenu * >(argp1);
40753 ecode2 = SWIG_AsVal_int(obj1, &val2);
40754 if (!SWIG_IsOK(ecode2)) {
40755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40756 }
40757 arg2 = static_cast< int >(val2);
40758 {
40759 arg3 = wxString_in_helper(obj2);
40760 if (arg3 == NULL) SWIG_fail;
40761 temp3 = true;
40762 }
40763 if (obj3) {
40764 {
40765 arg4 = wxString_in_helper(obj3);
40766 if (arg4 == NULL) SWIG_fail;
40767 temp4 = true;
40768 }
40769 }
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40773 wxPyEndAllowThreads(__tstate);
40774 if (PyErr_Occurred()) SWIG_fail;
40775 }
40776 {
40777 resultobj = wxPyMake_wxObject(result, (bool)0);
40778 }
40779 {
40780 if (temp3)
40781 delete arg3;
40782 }
40783 {
40784 if (temp4)
40785 delete arg4;
40786 }
40787 return resultobj;
40788 fail:
40789 {
40790 if (temp3)
40791 delete arg3;
40792 }
40793 {
40794 if (temp4)
40795 delete arg4;
40796 }
40797 return NULL;
40798 }
40799
40800
40801 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40802 PyObject *resultobj = 0;
40803 wxMenu *arg1 = (wxMenu *) 0 ;
40804 int arg2 ;
40805 wxString *arg3 = 0 ;
40806 wxString const &arg4_defvalue = wxPyEmptyString ;
40807 wxString *arg4 = (wxString *) &arg4_defvalue ;
40808 wxMenuItem *result = 0 ;
40809 void *argp1 = 0 ;
40810 int res1 = 0 ;
40811 int val2 ;
40812 int ecode2 = 0 ;
40813 bool temp3 = false ;
40814 bool temp4 = false ;
40815 PyObject * obj0 = 0 ;
40816 PyObject * obj1 = 0 ;
40817 PyObject * obj2 = 0 ;
40818 PyObject * obj3 = 0 ;
40819 char * kwnames[] = {
40820 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40821 };
40822
40823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40825 if (!SWIG_IsOK(res1)) {
40826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40827 }
40828 arg1 = reinterpret_cast< wxMenu * >(argp1);
40829 ecode2 = SWIG_AsVal_int(obj1, &val2);
40830 if (!SWIG_IsOK(ecode2)) {
40831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40832 }
40833 arg2 = static_cast< int >(val2);
40834 {
40835 arg3 = wxString_in_helper(obj2);
40836 if (arg3 == NULL) SWIG_fail;
40837 temp3 = true;
40838 }
40839 if (obj3) {
40840 {
40841 arg4 = wxString_in_helper(obj3);
40842 if (arg4 == NULL) SWIG_fail;
40843 temp4 = true;
40844 }
40845 }
40846 {
40847 PyThreadState* __tstate = wxPyBeginAllowThreads();
40848 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40849 wxPyEndAllowThreads(__tstate);
40850 if (PyErr_Occurred()) SWIG_fail;
40851 }
40852 {
40853 resultobj = wxPyMake_wxObject(result, (bool)0);
40854 }
40855 {
40856 if (temp3)
40857 delete arg3;
40858 }
40859 {
40860 if (temp4)
40861 delete arg4;
40862 }
40863 return resultobj;
40864 fail:
40865 {
40866 if (temp3)
40867 delete arg3;
40868 }
40869 {
40870 if (temp4)
40871 delete arg4;
40872 }
40873 return NULL;
40874 }
40875
40876
40877 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40878 PyObject *resultobj = 0;
40879 wxMenu *arg1 = (wxMenu *) 0 ;
40880 int arg2 ;
40881 wxString *arg3 = 0 ;
40882 wxMenu *arg4 = (wxMenu *) 0 ;
40883 wxString const &arg5_defvalue = wxPyEmptyString ;
40884 wxString *arg5 = (wxString *) &arg5_defvalue ;
40885 wxMenuItem *result = 0 ;
40886 void *argp1 = 0 ;
40887 int res1 = 0 ;
40888 int val2 ;
40889 int ecode2 = 0 ;
40890 bool temp3 = false ;
40891 void *argp4 = 0 ;
40892 int res4 = 0 ;
40893 bool temp5 = false ;
40894 PyObject * obj0 = 0 ;
40895 PyObject * obj1 = 0 ;
40896 PyObject * obj2 = 0 ;
40897 PyObject * obj3 = 0 ;
40898 PyObject * obj4 = 0 ;
40899 char * kwnames[] = {
40900 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40901 };
40902
40903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40905 if (!SWIG_IsOK(res1)) {
40906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40907 }
40908 arg1 = reinterpret_cast< wxMenu * >(argp1);
40909 ecode2 = SWIG_AsVal_int(obj1, &val2);
40910 if (!SWIG_IsOK(ecode2)) {
40911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40912 }
40913 arg2 = static_cast< int >(val2);
40914 {
40915 arg3 = wxString_in_helper(obj2);
40916 if (arg3 == NULL) SWIG_fail;
40917 temp3 = true;
40918 }
40919 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40920 if (!SWIG_IsOK(res4)) {
40921 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40922 }
40923 arg4 = reinterpret_cast< wxMenu * >(argp4);
40924 if (obj4) {
40925 {
40926 arg5 = wxString_in_helper(obj4);
40927 if (arg5 == NULL) SWIG_fail;
40928 temp5 = true;
40929 }
40930 }
40931 {
40932 PyThreadState* __tstate = wxPyBeginAllowThreads();
40933 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40934 wxPyEndAllowThreads(__tstate);
40935 if (PyErr_Occurred()) SWIG_fail;
40936 }
40937 {
40938 resultobj = wxPyMake_wxObject(result, (bool)0);
40939 }
40940 {
40941 if (temp3)
40942 delete arg3;
40943 }
40944 {
40945 if (temp5)
40946 delete arg5;
40947 }
40948 return resultobj;
40949 fail:
40950 {
40951 if (temp3)
40952 delete arg3;
40953 }
40954 {
40955 if (temp5)
40956 delete arg5;
40957 }
40958 return NULL;
40959 }
40960
40961
40962 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40963 PyObject *resultobj = 0;
40964 wxMenu *arg1 = (wxMenu *) 0 ;
40965 int arg2 ;
40966 wxMenuItem *result = 0 ;
40967 void *argp1 = 0 ;
40968 int res1 = 0 ;
40969 int val2 ;
40970 int ecode2 = 0 ;
40971 PyObject * obj0 = 0 ;
40972 PyObject * obj1 = 0 ;
40973 char * kwnames[] = {
40974 (char *) "self",(char *) "id", NULL
40975 };
40976
40977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40979 if (!SWIG_IsOK(res1)) {
40980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40981 }
40982 arg1 = reinterpret_cast< wxMenu * >(argp1);
40983 ecode2 = SWIG_AsVal_int(obj1, &val2);
40984 if (!SWIG_IsOK(ecode2)) {
40985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40986 }
40987 arg2 = static_cast< int >(val2);
40988 {
40989 PyThreadState* __tstate = wxPyBeginAllowThreads();
40990 result = (wxMenuItem *)(arg1)->Remove(arg2);
40991 wxPyEndAllowThreads(__tstate);
40992 if (PyErr_Occurred()) SWIG_fail;
40993 }
40994 {
40995 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40996 }
40997 return resultobj;
40998 fail:
40999 return NULL;
41000 }
41001
41002
41003 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41004 PyObject *resultobj = 0;
41005 wxMenu *arg1 = (wxMenu *) 0 ;
41006 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41007 wxMenuItem *result = 0 ;
41008 void *argp1 = 0 ;
41009 int res1 = 0 ;
41010 void *argp2 = 0 ;
41011 int res2 = 0 ;
41012 PyObject * obj0 = 0 ;
41013 PyObject * obj1 = 0 ;
41014 char * kwnames[] = {
41015 (char *) "self",(char *) "item", NULL
41016 };
41017
41018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
41019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41020 if (!SWIG_IsOK(res1)) {
41021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41022 }
41023 arg1 = reinterpret_cast< wxMenu * >(argp1);
41024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41025 if (!SWIG_IsOK(res2)) {
41026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41027 }
41028 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41029 {
41030 PyThreadState* __tstate = wxPyBeginAllowThreads();
41031 result = (wxMenuItem *)(arg1)->Remove(arg2);
41032 wxPyEndAllowThreads(__tstate);
41033 if (PyErr_Occurred()) SWIG_fail;
41034 }
41035 {
41036 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41037 }
41038 return resultobj;
41039 fail:
41040 return NULL;
41041 }
41042
41043
41044 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41045 PyObject *resultobj = 0;
41046 wxMenu *arg1 = (wxMenu *) 0 ;
41047 int arg2 ;
41048 bool result;
41049 void *argp1 = 0 ;
41050 int res1 = 0 ;
41051 int val2 ;
41052 int ecode2 = 0 ;
41053 PyObject * obj0 = 0 ;
41054 PyObject * obj1 = 0 ;
41055 char * kwnames[] = {
41056 (char *) "self",(char *) "id", NULL
41057 };
41058
41059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
41060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41061 if (!SWIG_IsOK(res1)) {
41062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
41063 }
41064 arg1 = reinterpret_cast< wxMenu * >(argp1);
41065 ecode2 = SWIG_AsVal_int(obj1, &val2);
41066 if (!SWIG_IsOK(ecode2)) {
41067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
41068 }
41069 arg2 = static_cast< int >(val2);
41070 {
41071 PyThreadState* __tstate = wxPyBeginAllowThreads();
41072 result = (bool)(arg1)->Delete(arg2);
41073 wxPyEndAllowThreads(__tstate);
41074 if (PyErr_Occurred()) SWIG_fail;
41075 }
41076 {
41077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41078 }
41079 return resultobj;
41080 fail:
41081 return NULL;
41082 }
41083
41084
41085 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41086 PyObject *resultobj = 0;
41087 wxMenu *arg1 = (wxMenu *) 0 ;
41088 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41089 bool result;
41090 void *argp1 = 0 ;
41091 int res1 = 0 ;
41092 void *argp2 = 0 ;
41093 int res2 = 0 ;
41094 PyObject * obj0 = 0 ;
41095 PyObject * obj1 = 0 ;
41096 char * kwnames[] = {
41097 (char *) "self",(char *) "item", NULL
41098 };
41099
41100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
41101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41102 if (!SWIG_IsOK(res1)) {
41103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41104 }
41105 arg1 = reinterpret_cast< wxMenu * >(argp1);
41106 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41107 if (!SWIG_IsOK(res2)) {
41108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41109 }
41110 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41111 {
41112 PyThreadState* __tstate = wxPyBeginAllowThreads();
41113 result = (bool)(arg1)->Delete(arg2);
41114 wxPyEndAllowThreads(__tstate);
41115 if (PyErr_Occurred()) SWIG_fail;
41116 }
41117 {
41118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41119 }
41120 return resultobj;
41121 fail:
41122 return NULL;
41123 }
41124
41125
41126 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41127 PyObject *resultobj = 0;
41128 wxMenu *arg1 = (wxMenu *) 0 ;
41129 void *argp1 = 0 ;
41130 int res1 = 0 ;
41131 PyObject *swig_obj[1] ;
41132
41133 if (!args) SWIG_fail;
41134 swig_obj[0] = args;
41135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41136 if (!SWIG_IsOK(res1)) {
41137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
41138 }
41139 arg1 = reinterpret_cast< wxMenu * >(argp1);
41140 {
41141 PyThreadState* __tstate = wxPyBeginAllowThreads();
41142 wxMenu_Destroy(arg1);
41143 wxPyEndAllowThreads(__tstate);
41144 if (PyErr_Occurred()) SWIG_fail;
41145 }
41146 resultobj = SWIG_Py_Void();
41147 return resultobj;
41148 fail:
41149 return NULL;
41150 }
41151
41152
41153 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41154 PyObject *resultobj = 0;
41155 wxMenu *arg1 = (wxMenu *) 0 ;
41156 int arg2 ;
41157 bool result;
41158 void *argp1 = 0 ;
41159 int res1 = 0 ;
41160 int val2 ;
41161 int ecode2 = 0 ;
41162 PyObject * obj0 = 0 ;
41163 PyObject * obj1 = 0 ;
41164 char * kwnames[] = {
41165 (char *) "self",(char *) "id", NULL
41166 };
41167
41168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
41169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41170 if (!SWIG_IsOK(res1)) {
41171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
41172 }
41173 arg1 = reinterpret_cast< wxMenu * >(argp1);
41174 ecode2 = SWIG_AsVal_int(obj1, &val2);
41175 if (!SWIG_IsOK(ecode2)) {
41176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
41177 }
41178 arg2 = static_cast< int >(val2);
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 result = (bool)(arg1)->Destroy(arg2);
41182 wxPyEndAllowThreads(__tstate);
41183 if (PyErr_Occurred()) SWIG_fail;
41184 }
41185 {
41186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41187 }
41188 return resultobj;
41189 fail:
41190 return NULL;
41191 }
41192
41193
41194 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41195 PyObject *resultobj = 0;
41196 wxMenu *arg1 = (wxMenu *) 0 ;
41197 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41198 bool result;
41199 void *argp1 = 0 ;
41200 int res1 = 0 ;
41201 void *argp2 = 0 ;
41202 int res2 = 0 ;
41203 PyObject * obj0 = 0 ;
41204 PyObject * obj1 = 0 ;
41205 char * kwnames[] = {
41206 (char *) "self",(char *) "item", NULL
41207 };
41208
41209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41211 if (!SWIG_IsOK(res1)) {
41212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41213 }
41214 arg1 = reinterpret_cast< wxMenu * >(argp1);
41215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41216 if (!SWIG_IsOK(res2)) {
41217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41218 }
41219 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41220 {
41221 PyThreadState* __tstate = wxPyBeginAllowThreads();
41222 result = (bool)(arg1)->Destroy(arg2);
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 {
41227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41228 }
41229 return resultobj;
41230 fail:
41231 return NULL;
41232 }
41233
41234
41235 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41236 PyObject *resultobj = 0;
41237 wxMenu *arg1 = (wxMenu *) 0 ;
41238 size_t result;
41239 void *argp1 = 0 ;
41240 int res1 = 0 ;
41241 PyObject *swig_obj[1] ;
41242
41243 if (!args) SWIG_fail;
41244 swig_obj[0] = args;
41245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41246 if (!SWIG_IsOK(res1)) {
41247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41248 }
41249 arg1 = reinterpret_cast< wxMenu * >(argp1);
41250 {
41251 PyThreadState* __tstate = wxPyBeginAllowThreads();
41252 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41253 wxPyEndAllowThreads(__tstate);
41254 if (PyErr_Occurred()) SWIG_fail;
41255 }
41256 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41257 return resultobj;
41258 fail:
41259 return NULL;
41260 }
41261
41262
41263 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41264 PyObject *resultobj = 0;
41265 wxMenu *arg1 = (wxMenu *) 0 ;
41266 PyObject *result = 0 ;
41267 void *argp1 = 0 ;
41268 int res1 = 0 ;
41269 PyObject *swig_obj[1] ;
41270
41271 if (!args) SWIG_fail;
41272 swig_obj[0] = args;
41273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41274 if (!SWIG_IsOK(res1)) {
41275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41276 }
41277 arg1 = reinterpret_cast< wxMenu * >(argp1);
41278 {
41279 PyThreadState* __tstate = wxPyBeginAllowThreads();
41280 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41281 wxPyEndAllowThreads(__tstate);
41282 if (PyErr_Occurred()) SWIG_fail;
41283 }
41284 resultobj = result;
41285 return resultobj;
41286 fail:
41287 return NULL;
41288 }
41289
41290
41291 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41292 PyObject *resultobj = 0;
41293 wxMenu *arg1 = (wxMenu *) 0 ;
41294 wxString *arg2 = 0 ;
41295 int result;
41296 void *argp1 = 0 ;
41297 int res1 = 0 ;
41298 bool temp2 = false ;
41299 PyObject * obj0 = 0 ;
41300 PyObject * obj1 = 0 ;
41301 char * kwnames[] = {
41302 (char *) "self",(char *) "item", NULL
41303 };
41304
41305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41307 if (!SWIG_IsOK(res1)) {
41308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41309 }
41310 arg1 = reinterpret_cast< wxMenu * >(argp1);
41311 {
41312 arg2 = wxString_in_helper(obj1);
41313 if (arg2 == NULL) SWIG_fail;
41314 temp2 = true;
41315 }
41316 {
41317 PyThreadState* __tstate = wxPyBeginAllowThreads();
41318 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41319 wxPyEndAllowThreads(__tstate);
41320 if (PyErr_Occurred()) SWIG_fail;
41321 }
41322 resultobj = SWIG_From_int(static_cast< int >(result));
41323 {
41324 if (temp2)
41325 delete arg2;
41326 }
41327 return resultobj;
41328 fail:
41329 {
41330 if (temp2)
41331 delete arg2;
41332 }
41333 return NULL;
41334 }
41335
41336
41337 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41338 PyObject *resultobj = 0;
41339 wxMenu *arg1 = (wxMenu *) 0 ;
41340 int arg2 ;
41341 wxMenuItem *result = 0 ;
41342 void *argp1 = 0 ;
41343 int res1 = 0 ;
41344 int val2 ;
41345 int ecode2 = 0 ;
41346 PyObject * obj0 = 0 ;
41347 PyObject * obj1 = 0 ;
41348 char * kwnames[] = {
41349 (char *) "self",(char *) "id", NULL
41350 };
41351
41352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41354 if (!SWIG_IsOK(res1)) {
41355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41356 }
41357 arg1 = reinterpret_cast< wxMenu * >(argp1);
41358 ecode2 = SWIG_AsVal_int(obj1, &val2);
41359 if (!SWIG_IsOK(ecode2)) {
41360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41361 }
41362 arg2 = static_cast< int >(val2);
41363 {
41364 PyThreadState* __tstate = wxPyBeginAllowThreads();
41365 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41366 wxPyEndAllowThreads(__tstate);
41367 if (PyErr_Occurred()) SWIG_fail;
41368 }
41369 {
41370 resultobj = wxPyMake_wxObject(result, (bool)0);
41371 }
41372 return resultobj;
41373 fail:
41374 return NULL;
41375 }
41376
41377
41378 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41379 PyObject *resultobj = 0;
41380 wxMenu *arg1 = (wxMenu *) 0 ;
41381 size_t arg2 ;
41382 wxMenuItem *result = 0 ;
41383 void *argp1 = 0 ;
41384 int res1 = 0 ;
41385 size_t val2 ;
41386 int ecode2 = 0 ;
41387 PyObject * obj0 = 0 ;
41388 PyObject * obj1 = 0 ;
41389 char * kwnames[] = {
41390 (char *) "self",(char *) "position", NULL
41391 };
41392
41393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41395 if (!SWIG_IsOK(res1)) {
41396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41397 }
41398 arg1 = reinterpret_cast< wxMenu * >(argp1);
41399 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41400 if (!SWIG_IsOK(ecode2)) {
41401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41402 }
41403 arg2 = static_cast< size_t >(val2);
41404 {
41405 PyThreadState* __tstate = wxPyBeginAllowThreads();
41406 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41407 wxPyEndAllowThreads(__tstate);
41408 if (PyErr_Occurred()) SWIG_fail;
41409 }
41410 {
41411 resultobj = wxPyMake_wxObject(result, (bool)0);
41412 }
41413 return resultobj;
41414 fail:
41415 return NULL;
41416 }
41417
41418
41419 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41420 PyObject *resultobj = 0;
41421 wxMenu *arg1 = (wxMenu *) 0 ;
41422 int arg2 ;
41423 bool arg3 ;
41424 void *argp1 = 0 ;
41425 int res1 = 0 ;
41426 int val2 ;
41427 int ecode2 = 0 ;
41428 bool val3 ;
41429 int ecode3 = 0 ;
41430 PyObject * obj0 = 0 ;
41431 PyObject * obj1 = 0 ;
41432 PyObject * obj2 = 0 ;
41433 char * kwnames[] = {
41434 (char *) "self",(char *) "id",(char *) "enable", NULL
41435 };
41436
41437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41439 if (!SWIG_IsOK(res1)) {
41440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41441 }
41442 arg1 = reinterpret_cast< wxMenu * >(argp1);
41443 ecode2 = SWIG_AsVal_int(obj1, &val2);
41444 if (!SWIG_IsOK(ecode2)) {
41445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41446 }
41447 arg2 = static_cast< int >(val2);
41448 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41449 if (!SWIG_IsOK(ecode3)) {
41450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41451 }
41452 arg3 = static_cast< bool >(val3);
41453 {
41454 PyThreadState* __tstate = wxPyBeginAllowThreads();
41455 (arg1)->Enable(arg2,arg3);
41456 wxPyEndAllowThreads(__tstate);
41457 if (PyErr_Occurred()) SWIG_fail;
41458 }
41459 resultobj = SWIG_Py_Void();
41460 return resultobj;
41461 fail:
41462 return NULL;
41463 }
41464
41465
41466 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41467 PyObject *resultobj = 0;
41468 wxMenu *arg1 = (wxMenu *) 0 ;
41469 int arg2 ;
41470 bool result;
41471 void *argp1 = 0 ;
41472 int res1 = 0 ;
41473 int val2 ;
41474 int ecode2 = 0 ;
41475 PyObject * obj0 = 0 ;
41476 PyObject * obj1 = 0 ;
41477 char * kwnames[] = {
41478 (char *) "self",(char *) "id", NULL
41479 };
41480
41481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41483 if (!SWIG_IsOK(res1)) {
41484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41485 }
41486 arg1 = reinterpret_cast< wxMenu * >(argp1);
41487 ecode2 = SWIG_AsVal_int(obj1, &val2);
41488 if (!SWIG_IsOK(ecode2)) {
41489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41490 }
41491 arg2 = static_cast< int >(val2);
41492 {
41493 PyThreadState* __tstate = wxPyBeginAllowThreads();
41494 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41495 wxPyEndAllowThreads(__tstate);
41496 if (PyErr_Occurred()) SWIG_fail;
41497 }
41498 {
41499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41500 }
41501 return resultobj;
41502 fail:
41503 return NULL;
41504 }
41505
41506
41507 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41508 PyObject *resultobj = 0;
41509 wxMenu *arg1 = (wxMenu *) 0 ;
41510 int arg2 ;
41511 bool arg3 ;
41512 void *argp1 = 0 ;
41513 int res1 = 0 ;
41514 int val2 ;
41515 int ecode2 = 0 ;
41516 bool val3 ;
41517 int ecode3 = 0 ;
41518 PyObject * obj0 = 0 ;
41519 PyObject * obj1 = 0 ;
41520 PyObject * obj2 = 0 ;
41521 char * kwnames[] = {
41522 (char *) "self",(char *) "id",(char *) "check", NULL
41523 };
41524
41525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41527 if (!SWIG_IsOK(res1)) {
41528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41529 }
41530 arg1 = reinterpret_cast< wxMenu * >(argp1);
41531 ecode2 = SWIG_AsVal_int(obj1, &val2);
41532 if (!SWIG_IsOK(ecode2)) {
41533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41534 }
41535 arg2 = static_cast< int >(val2);
41536 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41537 if (!SWIG_IsOK(ecode3)) {
41538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41539 }
41540 arg3 = static_cast< bool >(val3);
41541 {
41542 PyThreadState* __tstate = wxPyBeginAllowThreads();
41543 (arg1)->Check(arg2,arg3);
41544 wxPyEndAllowThreads(__tstate);
41545 if (PyErr_Occurred()) SWIG_fail;
41546 }
41547 resultobj = SWIG_Py_Void();
41548 return resultobj;
41549 fail:
41550 return NULL;
41551 }
41552
41553
41554 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41555 PyObject *resultobj = 0;
41556 wxMenu *arg1 = (wxMenu *) 0 ;
41557 int arg2 ;
41558 bool result;
41559 void *argp1 = 0 ;
41560 int res1 = 0 ;
41561 int val2 ;
41562 int ecode2 = 0 ;
41563 PyObject * obj0 = 0 ;
41564 PyObject * obj1 = 0 ;
41565 char * kwnames[] = {
41566 (char *) "self",(char *) "id", NULL
41567 };
41568
41569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41571 if (!SWIG_IsOK(res1)) {
41572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41573 }
41574 arg1 = reinterpret_cast< wxMenu * >(argp1);
41575 ecode2 = SWIG_AsVal_int(obj1, &val2);
41576 if (!SWIG_IsOK(ecode2)) {
41577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41578 }
41579 arg2 = static_cast< int >(val2);
41580 {
41581 PyThreadState* __tstate = wxPyBeginAllowThreads();
41582 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41583 wxPyEndAllowThreads(__tstate);
41584 if (PyErr_Occurred()) SWIG_fail;
41585 }
41586 {
41587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41588 }
41589 return resultobj;
41590 fail:
41591 return NULL;
41592 }
41593
41594
41595 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41596 PyObject *resultobj = 0;
41597 wxMenu *arg1 = (wxMenu *) 0 ;
41598 int arg2 ;
41599 wxString *arg3 = 0 ;
41600 void *argp1 = 0 ;
41601 int res1 = 0 ;
41602 int val2 ;
41603 int ecode2 = 0 ;
41604 bool temp3 = false ;
41605 PyObject * obj0 = 0 ;
41606 PyObject * obj1 = 0 ;
41607 PyObject * obj2 = 0 ;
41608 char * kwnames[] = {
41609 (char *) "self",(char *) "id",(char *) "label", NULL
41610 };
41611
41612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41614 if (!SWIG_IsOK(res1)) {
41615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41616 }
41617 arg1 = reinterpret_cast< wxMenu * >(argp1);
41618 ecode2 = SWIG_AsVal_int(obj1, &val2);
41619 if (!SWIG_IsOK(ecode2)) {
41620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41621 }
41622 arg2 = static_cast< int >(val2);
41623 {
41624 arg3 = wxString_in_helper(obj2);
41625 if (arg3 == NULL) SWIG_fail;
41626 temp3 = true;
41627 }
41628 {
41629 PyThreadState* __tstate = wxPyBeginAllowThreads();
41630 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41631 wxPyEndAllowThreads(__tstate);
41632 if (PyErr_Occurred()) SWIG_fail;
41633 }
41634 resultobj = SWIG_Py_Void();
41635 {
41636 if (temp3)
41637 delete arg3;
41638 }
41639 return resultobj;
41640 fail:
41641 {
41642 if (temp3)
41643 delete arg3;
41644 }
41645 return NULL;
41646 }
41647
41648
41649 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41650 PyObject *resultobj = 0;
41651 wxMenu *arg1 = (wxMenu *) 0 ;
41652 int arg2 ;
41653 wxString result;
41654 void *argp1 = 0 ;
41655 int res1 = 0 ;
41656 int val2 ;
41657 int ecode2 = 0 ;
41658 PyObject * obj0 = 0 ;
41659 PyObject * obj1 = 0 ;
41660 char * kwnames[] = {
41661 (char *) "self",(char *) "id", NULL
41662 };
41663
41664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41666 if (!SWIG_IsOK(res1)) {
41667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41668 }
41669 arg1 = reinterpret_cast< wxMenu * >(argp1);
41670 ecode2 = SWIG_AsVal_int(obj1, &val2);
41671 if (!SWIG_IsOK(ecode2)) {
41672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41673 }
41674 arg2 = static_cast< int >(val2);
41675 {
41676 PyThreadState* __tstate = wxPyBeginAllowThreads();
41677 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41678 wxPyEndAllowThreads(__tstate);
41679 if (PyErr_Occurred()) SWIG_fail;
41680 }
41681 {
41682 #if wxUSE_UNICODE
41683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41684 #else
41685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41686 #endif
41687 }
41688 return resultobj;
41689 fail:
41690 return NULL;
41691 }
41692
41693
41694 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41695 PyObject *resultobj = 0;
41696 wxMenu *arg1 = (wxMenu *) 0 ;
41697 int arg2 ;
41698 wxString *arg3 = 0 ;
41699 void *argp1 = 0 ;
41700 int res1 = 0 ;
41701 int val2 ;
41702 int ecode2 = 0 ;
41703 bool temp3 = false ;
41704 PyObject * obj0 = 0 ;
41705 PyObject * obj1 = 0 ;
41706 PyObject * obj2 = 0 ;
41707 char * kwnames[] = {
41708 (char *) "self",(char *) "id",(char *) "helpString", NULL
41709 };
41710
41711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41713 if (!SWIG_IsOK(res1)) {
41714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41715 }
41716 arg1 = reinterpret_cast< wxMenu * >(argp1);
41717 ecode2 = SWIG_AsVal_int(obj1, &val2);
41718 if (!SWIG_IsOK(ecode2)) {
41719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41720 }
41721 arg2 = static_cast< int >(val2);
41722 {
41723 arg3 = wxString_in_helper(obj2);
41724 if (arg3 == NULL) SWIG_fail;
41725 temp3 = true;
41726 }
41727 {
41728 PyThreadState* __tstate = wxPyBeginAllowThreads();
41729 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41730 wxPyEndAllowThreads(__tstate);
41731 if (PyErr_Occurred()) SWIG_fail;
41732 }
41733 resultobj = SWIG_Py_Void();
41734 {
41735 if (temp3)
41736 delete arg3;
41737 }
41738 return resultobj;
41739 fail:
41740 {
41741 if (temp3)
41742 delete arg3;
41743 }
41744 return NULL;
41745 }
41746
41747
41748 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41749 PyObject *resultobj = 0;
41750 wxMenu *arg1 = (wxMenu *) 0 ;
41751 int arg2 ;
41752 wxString result;
41753 void *argp1 = 0 ;
41754 int res1 = 0 ;
41755 int val2 ;
41756 int ecode2 = 0 ;
41757 PyObject * obj0 = 0 ;
41758 PyObject * obj1 = 0 ;
41759 char * kwnames[] = {
41760 (char *) "self",(char *) "id", NULL
41761 };
41762
41763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41765 if (!SWIG_IsOK(res1)) {
41766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41767 }
41768 arg1 = reinterpret_cast< wxMenu * >(argp1);
41769 ecode2 = SWIG_AsVal_int(obj1, &val2);
41770 if (!SWIG_IsOK(ecode2)) {
41771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41772 }
41773 arg2 = static_cast< int >(val2);
41774 {
41775 PyThreadState* __tstate = wxPyBeginAllowThreads();
41776 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41777 wxPyEndAllowThreads(__tstate);
41778 if (PyErr_Occurred()) SWIG_fail;
41779 }
41780 {
41781 #if wxUSE_UNICODE
41782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41783 #else
41784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41785 #endif
41786 }
41787 return resultobj;
41788 fail:
41789 return NULL;
41790 }
41791
41792
41793 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41794 PyObject *resultobj = 0;
41795 wxMenu *arg1 = (wxMenu *) 0 ;
41796 wxString *arg2 = 0 ;
41797 void *argp1 = 0 ;
41798 int res1 = 0 ;
41799 bool temp2 = false ;
41800 PyObject * obj0 = 0 ;
41801 PyObject * obj1 = 0 ;
41802 char * kwnames[] = {
41803 (char *) "self",(char *) "title", NULL
41804 };
41805
41806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41808 if (!SWIG_IsOK(res1)) {
41809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41810 }
41811 arg1 = reinterpret_cast< wxMenu * >(argp1);
41812 {
41813 arg2 = wxString_in_helper(obj1);
41814 if (arg2 == NULL) SWIG_fail;
41815 temp2 = true;
41816 }
41817 {
41818 PyThreadState* __tstate = wxPyBeginAllowThreads();
41819 (arg1)->SetTitle((wxString const &)*arg2);
41820 wxPyEndAllowThreads(__tstate);
41821 if (PyErr_Occurred()) SWIG_fail;
41822 }
41823 resultobj = SWIG_Py_Void();
41824 {
41825 if (temp2)
41826 delete arg2;
41827 }
41828 return resultobj;
41829 fail:
41830 {
41831 if (temp2)
41832 delete arg2;
41833 }
41834 return NULL;
41835 }
41836
41837
41838 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41839 PyObject *resultobj = 0;
41840 wxMenu *arg1 = (wxMenu *) 0 ;
41841 wxString result;
41842 void *argp1 = 0 ;
41843 int res1 = 0 ;
41844 PyObject *swig_obj[1] ;
41845
41846 if (!args) SWIG_fail;
41847 swig_obj[0] = args;
41848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41849 if (!SWIG_IsOK(res1)) {
41850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41851 }
41852 arg1 = reinterpret_cast< wxMenu * >(argp1);
41853 {
41854 PyThreadState* __tstate = wxPyBeginAllowThreads();
41855 result = ((wxMenu const *)arg1)->GetTitle();
41856 wxPyEndAllowThreads(__tstate);
41857 if (PyErr_Occurred()) SWIG_fail;
41858 }
41859 {
41860 #if wxUSE_UNICODE
41861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41862 #else
41863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41864 #endif
41865 }
41866 return resultobj;
41867 fail:
41868 return NULL;
41869 }
41870
41871
41872 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41873 PyObject *resultobj = 0;
41874 wxMenu *arg1 = (wxMenu *) 0 ;
41875 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41876 void *argp1 = 0 ;
41877 int res1 = 0 ;
41878 void *argp2 = 0 ;
41879 int res2 = 0 ;
41880 PyObject * obj0 = 0 ;
41881 PyObject * obj1 = 0 ;
41882 char * kwnames[] = {
41883 (char *) "self",(char *) "handler", NULL
41884 };
41885
41886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41888 if (!SWIG_IsOK(res1)) {
41889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41890 }
41891 arg1 = reinterpret_cast< wxMenu * >(argp1);
41892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41893 if (!SWIG_IsOK(res2)) {
41894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41895 }
41896 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41897 {
41898 PyThreadState* __tstate = wxPyBeginAllowThreads();
41899 (arg1)->SetEventHandler(arg2);
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 resultobj = SWIG_Py_Void();
41904 return resultobj;
41905 fail:
41906 return NULL;
41907 }
41908
41909
41910 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41911 PyObject *resultobj = 0;
41912 wxMenu *arg1 = (wxMenu *) 0 ;
41913 wxEvtHandler *result = 0 ;
41914 void *argp1 = 0 ;
41915 int res1 = 0 ;
41916 PyObject *swig_obj[1] ;
41917
41918 if (!args) SWIG_fail;
41919 swig_obj[0] = args;
41920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41921 if (!SWIG_IsOK(res1)) {
41922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41923 }
41924 arg1 = reinterpret_cast< wxMenu * >(argp1);
41925 {
41926 PyThreadState* __tstate = wxPyBeginAllowThreads();
41927 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41928 wxPyEndAllowThreads(__tstate);
41929 if (PyErr_Occurred()) SWIG_fail;
41930 }
41931 {
41932 resultobj = wxPyMake_wxObject(result, 0);
41933 }
41934 return resultobj;
41935 fail:
41936 return NULL;
41937 }
41938
41939
41940 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41941 PyObject *resultobj = 0;
41942 wxMenu *arg1 = (wxMenu *) 0 ;
41943 wxWindow *arg2 = (wxWindow *) 0 ;
41944 void *argp1 = 0 ;
41945 int res1 = 0 ;
41946 void *argp2 = 0 ;
41947 int res2 = 0 ;
41948 PyObject * obj0 = 0 ;
41949 PyObject * obj1 = 0 ;
41950 char * kwnames[] = {
41951 (char *) "self",(char *) "win", NULL
41952 };
41953
41954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41956 if (!SWIG_IsOK(res1)) {
41957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41958 }
41959 arg1 = reinterpret_cast< wxMenu * >(argp1);
41960 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41961 if (!SWIG_IsOK(res2)) {
41962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41963 }
41964 arg2 = reinterpret_cast< wxWindow * >(argp2);
41965 {
41966 PyThreadState* __tstate = wxPyBeginAllowThreads();
41967 (arg1)->SetInvokingWindow(arg2);
41968 wxPyEndAllowThreads(__tstate);
41969 if (PyErr_Occurred()) SWIG_fail;
41970 }
41971 resultobj = SWIG_Py_Void();
41972 return resultobj;
41973 fail:
41974 return NULL;
41975 }
41976
41977
41978 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41979 PyObject *resultobj = 0;
41980 wxMenu *arg1 = (wxMenu *) 0 ;
41981 wxWindow *result = 0 ;
41982 void *argp1 = 0 ;
41983 int res1 = 0 ;
41984 PyObject *swig_obj[1] ;
41985
41986 if (!args) SWIG_fail;
41987 swig_obj[0] = args;
41988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41989 if (!SWIG_IsOK(res1)) {
41990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41991 }
41992 arg1 = reinterpret_cast< wxMenu * >(argp1);
41993 {
41994 PyThreadState* __tstate = wxPyBeginAllowThreads();
41995 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41996 wxPyEndAllowThreads(__tstate);
41997 if (PyErr_Occurred()) SWIG_fail;
41998 }
41999 {
42000 resultobj = wxPyMake_wxObject(result, 0);
42001 }
42002 return resultobj;
42003 fail:
42004 return NULL;
42005 }
42006
42007
42008 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42009 PyObject *resultobj = 0;
42010 wxMenu *arg1 = (wxMenu *) 0 ;
42011 long result;
42012 void *argp1 = 0 ;
42013 int res1 = 0 ;
42014 PyObject *swig_obj[1] ;
42015
42016 if (!args) SWIG_fail;
42017 swig_obj[0] = args;
42018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42019 if (!SWIG_IsOK(res1)) {
42020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
42021 }
42022 arg1 = reinterpret_cast< wxMenu * >(argp1);
42023 {
42024 PyThreadState* __tstate = wxPyBeginAllowThreads();
42025 result = (long)((wxMenu const *)arg1)->GetStyle();
42026 wxPyEndAllowThreads(__tstate);
42027 if (PyErr_Occurred()) SWIG_fail;
42028 }
42029 resultobj = SWIG_From_long(static_cast< long >(result));
42030 return resultobj;
42031 fail:
42032 return NULL;
42033 }
42034
42035
42036 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42037 PyObject *resultobj = 0;
42038 wxMenu *arg1 = (wxMenu *) 0 ;
42039 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
42040 void *argp1 = 0 ;
42041 int res1 = 0 ;
42042 void *argp2 = 0 ;
42043 int res2 = 0 ;
42044 PyObject * obj0 = 0 ;
42045 PyObject * obj1 = 0 ;
42046 char * kwnames[] = {
42047 (char *) "self",(char *) "source", NULL
42048 };
42049
42050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
42051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42052 if (!SWIG_IsOK(res1)) {
42053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
42054 }
42055 arg1 = reinterpret_cast< wxMenu * >(argp1);
42056 if (obj1) {
42057 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
42058 if (!SWIG_IsOK(res2)) {
42059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
42060 }
42061 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
42062 }
42063 {
42064 PyThreadState* __tstate = wxPyBeginAllowThreads();
42065 (arg1)->UpdateUI(arg2);
42066 wxPyEndAllowThreads(__tstate);
42067 if (PyErr_Occurred()) SWIG_fail;
42068 }
42069 resultobj = SWIG_Py_Void();
42070 return resultobj;
42071 fail:
42072 return NULL;
42073 }
42074
42075
42076 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42077 PyObject *resultobj = 0;
42078 wxMenu *arg1 = (wxMenu *) 0 ;
42079 wxMenuBar *result = 0 ;
42080 void *argp1 = 0 ;
42081 int res1 = 0 ;
42082 PyObject *swig_obj[1] ;
42083
42084 if (!args) SWIG_fail;
42085 swig_obj[0] = args;
42086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42087 if (!SWIG_IsOK(res1)) {
42088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
42089 }
42090 arg1 = reinterpret_cast< wxMenu * >(argp1);
42091 {
42092 PyThreadState* __tstate = wxPyBeginAllowThreads();
42093 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
42094 wxPyEndAllowThreads(__tstate);
42095 if (PyErr_Occurred()) SWIG_fail;
42096 }
42097 {
42098 resultobj = wxPyMake_wxObject(result, (bool)0);
42099 }
42100 return resultobj;
42101 fail:
42102 return NULL;
42103 }
42104
42105
42106 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42107 PyObject *resultobj = 0;
42108 wxMenu *arg1 = (wxMenu *) 0 ;
42109 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
42110 void *argp1 = 0 ;
42111 int res1 = 0 ;
42112 void *argp2 = 0 ;
42113 int res2 = 0 ;
42114 PyObject * obj0 = 0 ;
42115 PyObject * obj1 = 0 ;
42116 char * kwnames[] = {
42117 (char *) "self",(char *) "menubar", NULL
42118 };
42119
42120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42122 if (!SWIG_IsOK(res1)) {
42123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
42124 }
42125 arg1 = reinterpret_cast< wxMenu * >(argp1);
42126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
42127 if (!SWIG_IsOK(res2)) {
42128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
42129 }
42130 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
42131 {
42132 PyThreadState* __tstate = wxPyBeginAllowThreads();
42133 (arg1)->Attach(arg2);
42134 wxPyEndAllowThreads(__tstate);
42135 if (PyErr_Occurred()) SWIG_fail;
42136 }
42137 resultobj = SWIG_Py_Void();
42138 return resultobj;
42139 fail:
42140 return NULL;
42141 }
42142
42143
42144 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42145 PyObject *resultobj = 0;
42146 wxMenu *arg1 = (wxMenu *) 0 ;
42147 void *argp1 = 0 ;
42148 int res1 = 0 ;
42149 PyObject *swig_obj[1] ;
42150
42151 if (!args) SWIG_fail;
42152 swig_obj[0] = args;
42153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42154 if (!SWIG_IsOK(res1)) {
42155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
42156 }
42157 arg1 = reinterpret_cast< wxMenu * >(argp1);
42158 {
42159 PyThreadState* __tstate = wxPyBeginAllowThreads();
42160 (arg1)->Detach();
42161 wxPyEndAllowThreads(__tstate);
42162 if (PyErr_Occurred()) SWIG_fail;
42163 }
42164 resultobj = SWIG_Py_Void();
42165 return resultobj;
42166 fail:
42167 return NULL;
42168 }
42169
42170
42171 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42172 PyObject *resultobj = 0;
42173 wxMenu *arg1 = (wxMenu *) 0 ;
42174 bool result;
42175 void *argp1 = 0 ;
42176 int res1 = 0 ;
42177 PyObject *swig_obj[1] ;
42178
42179 if (!args) SWIG_fail;
42180 swig_obj[0] = args;
42181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42182 if (!SWIG_IsOK(res1)) {
42183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42184 }
42185 arg1 = reinterpret_cast< wxMenu * >(argp1);
42186 {
42187 PyThreadState* __tstate = wxPyBeginAllowThreads();
42188 result = (bool)((wxMenu const *)arg1)->IsAttached();
42189 wxPyEndAllowThreads(__tstate);
42190 if (PyErr_Occurred()) SWIG_fail;
42191 }
42192 {
42193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42194 }
42195 return resultobj;
42196 fail:
42197 return NULL;
42198 }
42199
42200
42201 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42202 PyObject *resultobj = 0;
42203 wxMenu *arg1 = (wxMenu *) 0 ;
42204 wxMenu *arg2 = (wxMenu *) 0 ;
42205 void *argp1 = 0 ;
42206 int res1 = 0 ;
42207 void *argp2 = 0 ;
42208 int res2 = 0 ;
42209 PyObject * obj0 = 0 ;
42210 PyObject * obj1 = 0 ;
42211 char * kwnames[] = {
42212 (char *) "self",(char *) "parent", NULL
42213 };
42214
42215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42217 if (!SWIG_IsOK(res1)) {
42218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42219 }
42220 arg1 = reinterpret_cast< wxMenu * >(argp1);
42221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42222 if (!SWIG_IsOK(res2)) {
42223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42224 }
42225 arg2 = reinterpret_cast< wxMenu * >(argp2);
42226 {
42227 PyThreadState* __tstate = wxPyBeginAllowThreads();
42228 (arg1)->SetParent(arg2);
42229 wxPyEndAllowThreads(__tstate);
42230 if (PyErr_Occurred()) SWIG_fail;
42231 }
42232 resultobj = SWIG_Py_Void();
42233 return resultobj;
42234 fail:
42235 return NULL;
42236 }
42237
42238
42239 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42240 PyObject *resultobj = 0;
42241 wxMenu *arg1 = (wxMenu *) 0 ;
42242 wxMenu *result = 0 ;
42243 void *argp1 = 0 ;
42244 int res1 = 0 ;
42245 PyObject *swig_obj[1] ;
42246
42247 if (!args) SWIG_fail;
42248 swig_obj[0] = args;
42249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42250 if (!SWIG_IsOK(res1)) {
42251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42252 }
42253 arg1 = reinterpret_cast< wxMenu * >(argp1);
42254 {
42255 PyThreadState* __tstate = wxPyBeginAllowThreads();
42256 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42257 wxPyEndAllowThreads(__tstate);
42258 if (PyErr_Occurred()) SWIG_fail;
42259 }
42260 {
42261 resultobj = wxPyMake_wxObject(result, 0);
42262 }
42263 return resultobj;
42264 fail:
42265 return NULL;
42266 }
42267
42268
42269 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42270 PyObject *obj;
42271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42272 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42273 return SWIG_Py_Void();
42274 }
42275
42276 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42277 return SWIG_Python_InitShadowInstance(args);
42278 }
42279
42280 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42281 PyObject *resultobj = 0;
42282 long arg1 = (long) 0 ;
42283 wxMenuBar *result = 0 ;
42284 long val1 ;
42285 int ecode1 = 0 ;
42286 PyObject * obj0 = 0 ;
42287 char * kwnames[] = {
42288 (char *) "style", NULL
42289 };
42290
42291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42292 if (obj0) {
42293 ecode1 = SWIG_AsVal_long(obj0, &val1);
42294 if (!SWIG_IsOK(ecode1)) {
42295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42296 }
42297 arg1 = static_cast< long >(val1);
42298 }
42299 {
42300 if (!wxPyCheckForApp()) SWIG_fail;
42301 PyThreadState* __tstate = wxPyBeginAllowThreads();
42302 result = (wxMenuBar *)new wxMenuBar(arg1);
42303 wxPyEndAllowThreads(__tstate);
42304 if (PyErr_Occurred()) SWIG_fail;
42305 }
42306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42307 return resultobj;
42308 fail:
42309 return NULL;
42310 }
42311
42312
42313 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42314 PyObject *resultobj = 0;
42315 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42316 wxMenu *arg2 = (wxMenu *) 0 ;
42317 wxString *arg3 = 0 ;
42318 bool result;
42319 void *argp1 = 0 ;
42320 int res1 = 0 ;
42321 void *argp2 = 0 ;
42322 int res2 = 0 ;
42323 bool temp3 = false ;
42324 PyObject * obj0 = 0 ;
42325 PyObject * obj1 = 0 ;
42326 PyObject * obj2 = 0 ;
42327 char * kwnames[] = {
42328 (char *) "self",(char *) "menu",(char *) "title", NULL
42329 };
42330
42331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42333 if (!SWIG_IsOK(res1)) {
42334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42335 }
42336 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42338 if (!SWIG_IsOK(res2)) {
42339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42340 }
42341 arg2 = reinterpret_cast< wxMenu * >(argp2);
42342 {
42343 arg3 = wxString_in_helper(obj2);
42344 if (arg3 == NULL) SWIG_fail;
42345 temp3 = true;
42346 }
42347 {
42348 PyThreadState* __tstate = wxPyBeginAllowThreads();
42349 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42350 wxPyEndAllowThreads(__tstate);
42351 if (PyErr_Occurred()) SWIG_fail;
42352 }
42353 {
42354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42355 }
42356 {
42357 if (temp3)
42358 delete arg3;
42359 }
42360 return resultobj;
42361 fail:
42362 {
42363 if (temp3)
42364 delete arg3;
42365 }
42366 return NULL;
42367 }
42368
42369
42370 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42371 PyObject *resultobj = 0;
42372 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42373 size_t arg2 ;
42374 wxMenu *arg3 = (wxMenu *) 0 ;
42375 wxString *arg4 = 0 ;
42376 bool result;
42377 void *argp1 = 0 ;
42378 int res1 = 0 ;
42379 size_t val2 ;
42380 int ecode2 = 0 ;
42381 void *argp3 = 0 ;
42382 int res3 = 0 ;
42383 bool temp4 = false ;
42384 PyObject * obj0 = 0 ;
42385 PyObject * obj1 = 0 ;
42386 PyObject * obj2 = 0 ;
42387 PyObject * obj3 = 0 ;
42388 char * kwnames[] = {
42389 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42390 };
42391
42392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42394 if (!SWIG_IsOK(res1)) {
42395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42396 }
42397 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42398 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42399 if (!SWIG_IsOK(ecode2)) {
42400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42401 }
42402 arg2 = static_cast< size_t >(val2);
42403 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42404 if (!SWIG_IsOK(res3)) {
42405 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42406 }
42407 arg3 = reinterpret_cast< wxMenu * >(argp3);
42408 {
42409 arg4 = wxString_in_helper(obj3);
42410 if (arg4 == NULL) SWIG_fail;
42411 temp4 = true;
42412 }
42413 {
42414 PyThreadState* __tstate = wxPyBeginAllowThreads();
42415 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42416 wxPyEndAllowThreads(__tstate);
42417 if (PyErr_Occurred()) SWIG_fail;
42418 }
42419 {
42420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42421 }
42422 {
42423 if (temp4)
42424 delete arg4;
42425 }
42426 return resultobj;
42427 fail:
42428 {
42429 if (temp4)
42430 delete arg4;
42431 }
42432 return NULL;
42433 }
42434
42435
42436 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42437 PyObject *resultobj = 0;
42438 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42439 size_t result;
42440 void *argp1 = 0 ;
42441 int res1 = 0 ;
42442 PyObject *swig_obj[1] ;
42443
42444 if (!args) SWIG_fail;
42445 swig_obj[0] = args;
42446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42447 if (!SWIG_IsOK(res1)) {
42448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42449 }
42450 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42451 {
42452 PyThreadState* __tstate = wxPyBeginAllowThreads();
42453 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42454 wxPyEndAllowThreads(__tstate);
42455 if (PyErr_Occurred()) SWIG_fail;
42456 }
42457 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42458 return resultobj;
42459 fail:
42460 return NULL;
42461 }
42462
42463
42464 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42465 PyObject *resultobj = 0;
42466 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42467 size_t arg2 ;
42468 wxMenu *result = 0 ;
42469 void *argp1 = 0 ;
42470 int res1 = 0 ;
42471 size_t val2 ;
42472 int ecode2 = 0 ;
42473 PyObject * obj0 = 0 ;
42474 PyObject * obj1 = 0 ;
42475 char * kwnames[] = {
42476 (char *) "self",(char *) "pos", NULL
42477 };
42478
42479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42481 if (!SWIG_IsOK(res1)) {
42482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42483 }
42484 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42485 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42486 if (!SWIG_IsOK(ecode2)) {
42487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42488 }
42489 arg2 = static_cast< size_t >(val2);
42490 {
42491 PyThreadState* __tstate = wxPyBeginAllowThreads();
42492 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42493 wxPyEndAllowThreads(__tstate);
42494 if (PyErr_Occurred()) SWIG_fail;
42495 }
42496 {
42497 resultobj = wxPyMake_wxObject(result, 0);
42498 }
42499 return resultobj;
42500 fail:
42501 return NULL;
42502 }
42503
42504
42505 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42506 PyObject *resultobj = 0;
42507 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42508 size_t arg2 ;
42509 wxMenu *arg3 = (wxMenu *) 0 ;
42510 wxString *arg4 = 0 ;
42511 wxMenu *result = 0 ;
42512 void *argp1 = 0 ;
42513 int res1 = 0 ;
42514 size_t val2 ;
42515 int ecode2 = 0 ;
42516 void *argp3 = 0 ;
42517 int res3 = 0 ;
42518 bool temp4 = false ;
42519 PyObject * obj0 = 0 ;
42520 PyObject * obj1 = 0 ;
42521 PyObject * obj2 = 0 ;
42522 PyObject * obj3 = 0 ;
42523 char * kwnames[] = {
42524 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42525 };
42526
42527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42529 if (!SWIG_IsOK(res1)) {
42530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42531 }
42532 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42533 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42534 if (!SWIG_IsOK(ecode2)) {
42535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42536 }
42537 arg2 = static_cast< size_t >(val2);
42538 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42539 if (!SWIG_IsOK(res3)) {
42540 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42541 }
42542 arg3 = reinterpret_cast< wxMenu * >(argp3);
42543 {
42544 arg4 = wxString_in_helper(obj3);
42545 if (arg4 == NULL) SWIG_fail;
42546 temp4 = true;
42547 }
42548 {
42549 PyThreadState* __tstate = wxPyBeginAllowThreads();
42550 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42551 wxPyEndAllowThreads(__tstate);
42552 if (PyErr_Occurred()) SWIG_fail;
42553 }
42554 {
42555 resultobj = wxPyMake_wxObject(result, 0);
42556 }
42557 {
42558 if (temp4)
42559 delete arg4;
42560 }
42561 return resultobj;
42562 fail:
42563 {
42564 if (temp4)
42565 delete arg4;
42566 }
42567 return NULL;
42568 }
42569
42570
42571 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42572 PyObject *resultobj = 0;
42573 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42574 size_t arg2 ;
42575 wxMenu *result = 0 ;
42576 void *argp1 = 0 ;
42577 int res1 = 0 ;
42578 size_t val2 ;
42579 int ecode2 = 0 ;
42580 PyObject * obj0 = 0 ;
42581 PyObject * obj1 = 0 ;
42582 char * kwnames[] = {
42583 (char *) "self",(char *) "pos", NULL
42584 };
42585
42586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42588 if (!SWIG_IsOK(res1)) {
42589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42590 }
42591 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42592 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42593 if (!SWIG_IsOK(ecode2)) {
42594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42595 }
42596 arg2 = static_cast< size_t >(val2);
42597 {
42598 PyThreadState* __tstate = wxPyBeginAllowThreads();
42599 result = (wxMenu *)(arg1)->Remove(arg2);
42600 wxPyEndAllowThreads(__tstate);
42601 if (PyErr_Occurred()) SWIG_fail;
42602 }
42603 {
42604 resultobj = wxPyMake_wxObject(result, 0);
42605 }
42606 return resultobj;
42607 fail:
42608 return NULL;
42609 }
42610
42611
42612 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42613 PyObject *resultobj = 0;
42614 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42615 size_t arg2 ;
42616 bool arg3 ;
42617 void *argp1 = 0 ;
42618 int res1 = 0 ;
42619 size_t val2 ;
42620 int ecode2 = 0 ;
42621 bool val3 ;
42622 int ecode3 = 0 ;
42623 PyObject * obj0 = 0 ;
42624 PyObject * obj1 = 0 ;
42625 PyObject * obj2 = 0 ;
42626 char * kwnames[] = {
42627 (char *) "self",(char *) "pos",(char *) "enable", NULL
42628 };
42629
42630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42632 if (!SWIG_IsOK(res1)) {
42633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42634 }
42635 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42636 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42637 if (!SWIG_IsOK(ecode2)) {
42638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42639 }
42640 arg2 = static_cast< size_t >(val2);
42641 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42642 if (!SWIG_IsOK(ecode3)) {
42643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42644 }
42645 arg3 = static_cast< bool >(val3);
42646 {
42647 PyThreadState* __tstate = wxPyBeginAllowThreads();
42648 (arg1)->EnableTop(arg2,arg3);
42649 wxPyEndAllowThreads(__tstate);
42650 if (PyErr_Occurred()) SWIG_fail;
42651 }
42652 resultobj = SWIG_Py_Void();
42653 return resultobj;
42654 fail:
42655 return NULL;
42656 }
42657
42658
42659 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42660 PyObject *resultobj = 0;
42661 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42662 size_t arg2 ;
42663 bool result;
42664 void *argp1 = 0 ;
42665 int res1 = 0 ;
42666 size_t val2 ;
42667 int ecode2 = 0 ;
42668 PyObject * obj0 = 0 ;
42669 PyObject * obj1 = 0 ;
42670 char * kwnames[] = {
42671 (char *) "self",(char *) "pos", NULL
42672 };
42673
42674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42676 if (!SWIG_IsOK(res1)) {
42677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42678 }
42679 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42680 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42681 if (!SWIG_IsOK(ecode2)) {
42682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42683 }
42684 arg2 = static_cast< size_t >(val2);
42685 {
42686 PyThreadState* __tstate = wxPyBeginAllowThreads();
42687 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42688 wxPyEndAllowThreads(__tstate);
42689 if (PyErr_Occurred()) SWIG_fail;
42690 }
42691 {
42692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42693 }
42694 return resultobj;
42695 fail:
42696 return NULL;
42697 }
42698
42699
42700 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42701 PyObject *resultobj = 0;
42702 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42703 size_t arg2 ;
42704 wxString *arg3 = 0 ;
42705 void *argp1 = 0 ;
42706 int res1 = 0 ;
42707 size_t val2 ;
42708 int ecode2 = 0 ;
42709 bool temp3 = false ;
42710 PyObject * obj0 = 0 ;
42711 PyObject * obj1 = 0 ;
42712 PyObject * obj2 = 0 ;
42713 char * kwnames[] = {
42714 (char *) "self",(char *) "pos",(char *) "label", NULL
42715 };
42716
42717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42719 if (!SWIG_IsOK(res1)) {
42720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42721 }
42722 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42723 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42724 if (!SWIG_IsOK(ecode2)) {
42725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42726 }
42727 arg2 = static_cast< size_t >(val2);
42728 {
42729 arg3 = wxString_in_helper(obj2);
42730 if (arg3 == NULL) SWIG_fail;
42731 temp3 = true;
42732 }
42733 {
42734 PyThreadState* __tstate = wxPyBeginAllowThreads();
42735 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42736 wxPyEndAllowThreads(__tstate);
42737 if (PyErr_Occurred()) SWIG_fail;
42738 }
42739 resultobj = SWIG_Py_Void();
42740 {
42741 if (temp3)
42742 delete arg3;
42743 }
42744 return resultobj;
42745 fail:
42746 {
42747 if (temp3)
42748 delete arg3;
42749 }
42750 return NULL;
42751 }
42752
42753
42754 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42755 PyObject *resultobj = 0;
42756 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42757 size_t arg2 ;
42758 wxString result;
42759 void *argp1 = 0 ;
42760 int res1 = 0 ;
42761 size_t val2 ;
42762 int ecode2 = 0 ;
42763 PyObject * obj0 = 0 ;
42764 PyObject * obj1 = 0 ;
42765 char * kwnames[] = {
42766 (char *) "self",(char *) "pos", NULL
42767 };
42768
42769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42771 if (!SWIG_IsOK(res1)) {
42772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42773 }
42774 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42775 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42776 if (!SWIG_IsOK(ecode2)) {
42777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42778 }
42779 arg2 = static_cast< size_t >(val2);
42780 {
42781 PyThreadState* __tstate = wxPyBeginAllowThreads();
42782 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42783 wxPyEndAllowThreads(__tstate);
42784 if (PyErr_Occurred()) SWIG_fail;
42785 }
42786 {
42787 #if wxUSE_UNICODE
42788 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42789 #else
42790 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42791 #endif
42792 }
42793 return resultobj;
42794 fail:
42795 return NULL;
42796 }
42797
42798
42799 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42800 PyObject *resultobj = 0;
42801 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42802 wxString *arg2 = 0 ;
42803 wxString *arg3 = 0 ;
42804 int result;
42805 void *argp1 = 0 ;
42806 int res1 = 0 ;
42807 bool temp2 = false ;
42808 bool temp3 = false ;
42809 PyObject * obj0 = 0 ;
42810 PyObject * obj1 = 0 ;
42811 PyObject * obj2 = 0 ;
42812 char * kwnames[] = {
42813 (char *) "self",(char *) "menu",(char *) "item", NULL
42814 };
42815
42816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42818 if (!SWIG_IsOK(res1)) {
42819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42820 }
42821 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42822 {
42823 arg2 = wxString_in_helper(obj1);
42824 if (arg2 == NULL) SWIG_fail;
42825 temp2 = true;
42826 }
42827 {
42828 arg3 = wxString_in_helper(obj2);
42829 if (arg3 == NULL) SWIG_fail;
42830 temp3 = true;
42831 }
42832 {
42833 PyThreadState* __tstate = wxPyBeginAllowThreads();
42834 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42835 wxPyEndAllowThreads(__tstate);
42836 if (PyErr_Occurred()) SWIG_fail;
42837 }
42838 resultobj = SWIG_From_int(static_cast< int >(result));
42839 {
42840 if (temp2)
42841 delete arg2;
42842 }
42843 {
42844 if (temp3)
42845 delete arg3;
42846 }
42847 return resultobj;
42848 fail:
42849 {
42850 if (temp2)
42851 delete arg2;
42852 }
42853 {
42854 if (temp3)
42855 delete arg3;
42856 }
42857 return NULL;
42858 }
42859
42860
42861 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42862 PyObject *resultobj = 0;
42863 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42864 int arg2 ;
42865 wxMenuItem *result = 0 ;
42866 void *argp1 = 0 ;
42867 int res1 = 0 ;
42868 int val2 ;
42869 int ecode2 = 0 ;
42870 PyObject * obj0 = 0 ;
42871 PyObject * obj1 = 0 ;
42872 char * kwnames[] = {
42873 (char *) "self",(char *) "id", NULL
42874 };
42875
42876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42878 if (!SWIG_IsOK(res1)) {
42879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42880 }
42881 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42882 ecode2 = SWIG_AsVal_int(obj1, &val2);
42883 if (!SWIG_IsOK(ecode2)) {
42884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42885 }
42886 arg2 = static_cast< int >(val2);
42887 {
42888 PyThreadState* __tstate = wxPyBeginAllowThreads();
42889 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42890 wxPyEndAllowThreads(__tstate);
42891 if (PyErr_Occurred()) SWIG_fail;
42892 }
42893 {
42894 resultobj = wxPyMake_wxObject(result, (bool)0);
42895 }
42896 return resultobj;
42897 fail:
42898 return NULL;
42899 }
42900
42901
42902 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42903 PyObject *resultobj = 0;
42904 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42905 wxString *arg2 = 0 ;
42906 int result;
42907 void *argp1 = 0 ;
42908 int res1 = 0 ;
42909 bool temp2 = false ;
42910 PyObject * obj0 = 0 ;
42911 PyObject * obj1 = 0 ;
42912 char * kwnames[] = {
42913 (char *) "self",(char *) "title", NULL
42914 };
42915
42916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42918 if (!SWIG_IsOK(res1)) {
42919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42920 }
42921 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42922 {
42923 arg2 = wxString_in_helper(obj1);
42924 if (arg2 == NULL) SWIG_fail;
42925 temp2 = true;
42926 }
42927 {
42928 PyThreadState* __tstate = wxPyBeginAllowThreads();
42929 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42930 wxPyEndAllowThreads(__tstate);
42931 if (PyErr_Occurred()) SWIG_fail;
42932 }
42933 resultobj = SWIG_From_int(static_cast< int >(result));
42934 {
42935 if (temp2)
42936 delete arg2;
42937 }
42938 return resultobj;
42939 fail:
42940 {
42941 if (temp2)
42942 delete arg2;
42943 }
42944 return NULL;
42945 }
42946
42947
42948 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42949 PyObject *resultobj = 0;
42950 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42951 int arg2 ;
42952 bool arg3 ;
42953 void *argp1 = 0 ;
42954 int res1 = 0 ;
42955 int val2 ;
42956 int ecode2 = 0 ;
42957 bool val3 ;
42958 int ecode3 = 0 ;
42959 PyObject * obj0 = 0 ;
42960 PyObject * obj1 = 0 ;
42961 PyObject * obj2 = 0 ;
42962 char * kwnames[] = {
42963 (char *) "self",(char *) "id",(char *) "enable", NULL
42964 };
42965
42966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42968 if (!SWIG_IsOK(res1)) {
42969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42970 }
42971 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42972 ecode2 = SWIG_AsVal_int(obj1, &val2);
42973 if (!SWIG_IsOK(ecode2)) {
42974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42975 }
42976 arg2 = static_cast< int >(val2);
42977 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42978 if (!SWIG_IsOK(ecode3)) {
42979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42980 }
42981 arg3 = static_cast< bool >(val3);
42982 {
42983 PyThreadState* __tstate = wxPyBeginAllowThreads();
42984 (arg1)->Enable(arg2,arg3);
42985 wxPyEndAllowThreads(__tstate);
42986 if (PyErr_Occurred()) SWIG_fail;
42987 }
42988 resultobj = SWIG_Py_Void();
42989 return resultobj;
42990 fail:
42991 return NULL;
42992 }
42993
42994
42995 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42996 PyObject *resultobj = 0;
42997 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42998 int arg2 ;
42999 bool arg3 ;
43000 void *argp1 = 0 ;
43001 int res1 = 0 ;
43002 int val2 ;
43003 int ecode2 = 0 ;
43004 bool val3 ;
43005 int ecode3 = 0 ;
43006 PyObject * obj0 = 0 ;
43007 PyObject * obj1 = 0 ;
43008 PyObject * obj2 = 0 ;
43009 char * kwnames[] = {
43010 (char *) "self",(char *) "id",(char *) "check", NULL
43011 };
43012
43013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43015 if (!SWIG_IsOK(res1)) {
43016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43017 }
43018 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43019 ecode2 = SWIG_AsVal_int(obj1, &val2);
43020 if (!SWIG_IsOK(ecode2)) {
43021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
43022 }
43023 arg2 = static_cast< int >(val2);
43024 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43025 if (!SWIG_IsOK(ecode3)) {
43026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
43027 }
43028 arg3 = static_cast< bool >(val3);
43029 {
43030 PyThreadState* __tstate = wxPyBeginAllowThreads();
43031 (arg1)->Check(arg2,arg3);
43032 wxPyEndAllowThreads(__tstate);
43033 if (PyErr_Occurred()) SWIG_fail;
43034 }
43035 resultobj = SWIG_Py_Void();
43036 return resultobj;
43037 fail:
43038 return NULL;
43039 }
43040
43041
43042 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43043 PyObject *resultobj = 0;
43044 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43045 int arg2 ;
43046 bool result;
43047 void *argp1 = 0 ;
43048 int res1 = 0 ;
43049 int val2 ;
43050 int ecode2 = 0 ;
43051 PyObject * obj0 = 0 ;
43052 PyObject * obj1 = 0 ;
43053 char * kwnames[] = {
43054 (char *) "self",(char *) "id", NULL
43055 };
43056
43057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43059 if (!SWIG_IsOK(res1)) {
43060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43061 }
43062 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43063 ecode2 = SWIG_AsVal_int(obj1, &val2);
43064 if (!SWIG_IsOK(ecode2)) {
43065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
43066 }
43067 arg2 = static_cast< int >(val2);
43068 {
43069 PyThreadState* __tstate = wxPyBeginAllowThreads();
43070 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
43071 wxPyEndAllowThreads(__tstate);
43072 if (PyErr_Occurred()) SWIG_fail;
43073 }
43074 {
43075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43076 }
43077 return resultobj;
43078 fail:
43079 return NULL;
43080 }
43081
43082
43083 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43084 PyObject *resultobj = 0;
43085 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43086 int arg2 ;
43087 bool result;
43088 void *argp1 = 0 ;
43089 int res1 = 0 ;
43090 int val2 ;
43091 int ecode2 = 0 ;
43092 PyObject * obj0 = 0 ;
43093 PyObject * obj1 = 0 ;
43094 char * kwnames[] = {
43095 (char *) "self",(char *) "id", NULL
43096 };
43097
43098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43100 if (!SWIG_IsOK(res1)) {
43101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43102 }
43103 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43104 ecode2 = SWIG_AsVal_int(obj1, &val2);
43105 if (!SWIG_IsOK(ecode2)) {
43106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43107 }
43108 arg2 = static_cast< int >(val2);
43109 {
43110 PyThreadState* __tstate = wxPyBeginAllowThreads();
43111 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
43112 wxPyEndAllowThreads(__tstate);
43113 if (PyErr_Occurred()) SWIG_fail;
43114 }
43115 {
43116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43117 }
43118 return resultobj;
43119 fail:
43120 return NULL;
43121 }
43122
43123
43124 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43125 PyObject *resultobj = 0;
43126 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43127 int arg2 ;
43128 wxString *arg3 = 0 ;
43129 void *argp1 = 0 ;
43130 int res1 = 0 ;
43131 int val2 ;
43132 int ecode2 = 0 ;
43133 bool temp3 = false ;
43134 PyObject * obj0 = 0 ;
43135 PyObject * obj1 = 0 ;
43136 PyObject * obj2 = 0 ;
43137 char * kwnames[] = {
43138 (char *) "self",(char *) "id",(char *) "label", NULL
43139 };
43140
43141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43143 if (!SWIG_IsOK(res1)) {
43144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43145 }
43146 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43147 ecode2 = SWIG_AsVal_int(obj1, &val2);
43148 if (!SWIG_IsOK(ecode2)) {
43149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
43150 }
43151 arg2 = static_cast< int >(val2);
43152 {
43153 arg3 = wxString_in_helper(obj2);
43154 if (arg3 == NULL) SWIG_fail;
43155 temp3 = true;
43156 }
43157 {
43158 PyThreadState* __tstate = wxPyBeginAllowThreads();
43159 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43160 wxPyEndAllowThreads(__tstate);
43161 if (PyErr_Occurred()) SWIG_fail;
43162 }
43163 resultobj = SWIG_Py_Void();
43164 {
43165 if (temp3)
43166 delete arg3;
43167 }
43168 return resultobj;
43169 fail:
43170 {
43171 if (temp3)
43172 delete arg3;
43173 }
43174 return NULL;
43175 }
43176
43177
43178 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43179 PyObject *resultobj = 0;
43180 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43181 int arg2 ;
43182 wxString result;
43183 void *argp1 = 0 ;
43184 int res1 = 0 ;
43185 int val2 ;
43186 int ecode2 = 0 ;
43187 PyObject * obj0 = 0 ;
43188 PyObject * obj1 = 0 ;
43189 char * kwnames[] = {
43190 (char *) "self",(char *) "id", NULL
43191 };
43192
43193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43195 if (!SWIG_IsOK(res1)) {
43196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43197 }
43198 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43199 ecode2 = SWIG_AsVal_int(obj1, &val2);
43200 if (!SWIG_IsOK(ecode2)) {
43201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43202 }
43203 arg2 = static_cast< int >(val2);
43204 {
43205 PyThreadState* __tstate = wxPyBeginAllowThreads();
43206 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43207 wxPyEndAllowThreads(__tstate);
43208 if (PyErr_Occurred()) SWIG_fail;
43209 }
43210 {
43211 #if wxUSE_UNICODE
43212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43213 #else
43214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43215 #endif
43216 }
43217 return resultobj;
43218 fail:
43219 return NULL;
43220 }
43221
43222
43223 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43224 PyObject *resultobj = 0;
43225 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43226 int arg2 ;
43227 wxString *arg3 = 0 ;
43228 void *argp1 = 0 ;
43229 int res1 = 0 ;
43230 int val2 ;
43231 int ecode2 = 0 ;
43232 bool temp3 = false ;
43233 PyObject * obj0 = 0 ;
43234 PyObject * obj1 = 0 ;
43235 PyObject * obj2 = 0 ;
43236 char * kwnames[] = {
43237 (char *) "self",(char *) "id",(char *) "helpString", NULL
43238 };
43239
43240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43242 if (!SWIG_IsOK(res1)) {
43243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43244 }
43245 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43246 ecode2 = SWIG_AsVal_int(obj1, &val2);
43247 if (!SWIG_IsOK(ecode2)) {
43248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43249 }
43250 arg2 = static_cast< int >(val2);
43251 {
43252 arg3 = wxString_in_helper(obj2);
43253 if (arg3 == NULL) SWIG_fail;
43254 temp3 = true;
43255 }
43256 {
43257 PyThreadState* __tstate = wxPyBeginAllowThreads();
43258 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43259 wxPyEndAllowThreads(__tstate);
43260 if (PyErr_Occurred()) SWIG_fail;
43261 }
43262 resultobj = SWIG_Py_Void();
43263 {
43264 if (temp3)
43265 delete arg3;
43266 }
43267 return resultobj;
43268 fail:
43269 {
43270 if (temp3)
43271 delete arg3;
43272 }
43273 return NULL;
43274 }
43275
43276
43277 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43278 PyObject *resultobj = 0;
43279 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43280 int arg2 ;
43281 wxString result;
43282 void *argp1 = 0 ;
43283 int res1 = 0 ;
43284 int val2 ;
43285 int ecode2 = 0 ;
43286 PyObject * obj0 = 0 ;
43287 PyObject * obj1 = 0 ;
43288 char * kwnames[] = {
43289 (char *) "self",(char *) "id", NULL
43290 };
43291
43292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43294 if (!SWIG_IsOK(res1)) {
43295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43296 }
43297 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43298 ecode2 = SWIG_AsVal_int(obj1, &val2);
43299 if (!SWIG_IsOK(ecode2)) {
43300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43301 }
43302 arg2 = static_cast< int >(val2);
43303 {
43304 PyThreadState* __tstate = wxPyBeginAllowThreads();
43305 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43306 wxPyEndAllowThreads(__tstate);
43307 if (PyErr_Occurred()) SWIG_fail;
43308 }
43309 {
43310 #if wxUSE_UNICODE
43311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43312 #else
43313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43314 #endif
43315 }
43316 return resultobj;
43317 fail:
43318 return NULL;
43319 }
43320
43321
43322 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43323 PyObject *resultobj = 0;
43324 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43325 wxFrame *result = 0 ;
43326 void *argp1 = 0 ;
43327 int res1 = 0 ;
43328 PyObject *swig_obj[1] ;
43329
43330 if (!args) SWIG_fail;
43331 swig_obj[0] = args;
43332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43333 if (!SWIG_IsOK(res1)) {
43334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43335 }
43336 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43337 {
43338 PyThreadState* __tstate = wxPyBeginAllowThreads();
43339 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43340 wxPyEndAllowThreads(__tstate);
43341 if (PyErr_Occurred()) SWIG_fail;
43342 }
43343 {
43344 resultobj = wxPyMake_wxObject(result, (bool)0);
43345 }
43346 return resultobj;
43347 fail:
43348 return NULL;
43349 }
43350
43351
43352 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43353 PyObject *resultobj = 0;
43354 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43355 bool result;
43356 void *argp1 = 0 ;
43357 int res1 = 0 ;
43358 PyObject *swig_obj[1] ;
43359
43360 if (!args) SWIG_fail;
43361 swig_obj[0] = args;
43362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43363 if (!SWIG_IsOK(res1)) {
43364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43365 }
43366 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43367 {
43368 PyThreadState* __tstate = wxPyBeginAllowThreads();
43369 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43370 wxPyEndAllowThreads(__tstate);
43371 if (PyErr_Occurred()) SWIG_fail;
43372 }
43373 {
43374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43375 }
43376 return resultobj;
43377 fail:
43378 return NULL;
43379 }
43380
43381
43382 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43383 PyObject *resultobj = 0;
43384 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43385 wxFrame *arg2 = (wxFrame *) 0 ;
43386 void *argp1 = 0 ;
43387 int res1 = 0 ;
43388 void *argp2 = 0 ;
43389 int res2 = 0 ;
43390 PyObject * obj0 = 0 ;
43391 PyObject * obj1 = 0 ;
43392 char * kwnames[] = {
43393 (char *) "self",(char *) "frame", NULL
43394 };
43395
43396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43398 if (!SWIG_IsOK(res1)) {
43399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43400 }
43401 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43403 if (!SWIG_IsOK(res2)) {
43404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43405 }
43406 arg2 = reinterpret_cast< wxFrame * >(argp2);
43407 {
43408 PyThreadState* __tstate = wxPyBeginAllowThreads();
43409 (arg1)->Attach(arg2);
43410 wxPyEndAllowThreads(__tstate);
43411 if (PyErr_Occurred()) SWIG_fail;
43412 }
43413 resultobj = SWIG_Py_Void();
43414 return resultobj;
43415 fail:
43416 return NULL;
43417 }
43418
43419
43420 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43421 PyObject *resultobj = 0;
43422 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43423 void *argp1 = 0 ;
43424 int res1 = 0 ;
43425 PyObject *swig_obj[1] ;
43426
43427 if (!args) SWIG_fail;
43428 swig_obj[0] = args;
43429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43430 if (!SWIG_IsOK(res1)) {
43431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43432 }
43433 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43434 {
43435 PyThreadState* __tstate = wxPyBeginAllowThreads();
43436 (arg1)->Detach();
43437 wxPyEndAllowThreads(__tstate);
43438 if (PyErr_Occurred()) SWIG_fail;
43439 }
43440 resultobj = SWIG_Py_Void();
43441 return resultobj;
43442 fail:
43443 return NULL;
43444 }
43445
43446
43447 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43448 PyObject *resultobj = 0;
43449 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43450 void *argp1 = 0 ;
43451 int res1 = 0 ;
43452 PyObject *swig_obj[1] ;
43453
43454 if (!args) SWIG_fail;
43455 swig_obj[0] = args;
43456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43457 if (!SWIG_IsOK(res1)) {
43458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43459 }
43460 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43461 {
43462 PyThreadState* __tstate = wxPyBeginAllowThreads();
43463 (arg1)->UpdateMenus();
43464 wxPyEndAllowThreads(__tstate);
43465 if (PyErr_Occurred()) SWIG_fail;
43466 }
43467 resultobj = SWIG_Py_Void();
43468 return resultobj;
43469 fail:
43470 return NULL;
43471 }
43472
43473
43474 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43475 PyObject *resultobj = 0;
43476 bool arg1 ;
43477 bool val1 ;
43478 int ecode1 = 0 ;
43479 PyObject * obj0 = 0 ;
43480 char * kwnames[] = {
43481 (char *) "enable", NULL
43482 };
43483
43484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43485 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43486 if (!SWIG_IsOK(ecode1)) {
43487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43488 }
43489 arg1 = static_cast< bool >(val1);
43490 {
43491 PyThreadState* __tstate = wxPyBeginAllowThreads();
43492 wxMenuBar_SetAutoWindowMenu(arg1);
43493 wxPyEndAllowThreads(__tstate);
43494 if (PyErr_Occurred()) SWIG_fail;
43495 }
43496 resultobj = SWIG_Py_Void();
43497 return resultobj;
43498 fail:
43499 return NULL;
43500 }
43501
43502
43503 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43504 PyObject *resultobj = 0;
43505 bool result;
43506
43507 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43508 {
43509 PyThreadState* __tstate = wxPyBeginAllowThreads();
43510 result = (bool)wxMenuBar_GetAutoWindowMenu();
43511 wxPyEndAllowThreads(__tstate);
43512 if (PyErr_Occurred()) SWIG_fail;
43513 }
43514 {
43515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43516 }
43517 return resultobj;
43518 fail:
43519 return NULL;
43520 }
43521
43522
43523 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43524 PyObject *obj;
43525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43526 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43527 return SWIG_Py_Void();
43528 }
43529
43530 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43531 return SWIG_Python_InitShadowInstance(args);
43532 }
43533
43534 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43535 PyObject *resultobj = 0;
43536 wxMenu *arg1 = (wxMenu *) NULL ;
43537 int arg2 = (int) wxID_ANY ;
43538 wxString const &arg3_defvalue = wxPyEmptyString ;
43539 wxString *arg3 = (wxString *) &arg3_defvalue ;
43540 wxString const &arg4_defvalue = wxPyEmptyString ;
43541 wxString *arg4 = (wxString *) &arg4_defvalue ;
43542 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43543 wxMenu *arg6 = (wxMenu *) NULL ;
43544 wxMenuItem *result = 0 ;
43545 void *argp1 = 0 ;
43546 int res1 = 0 ;
43547 int val2 ;
43548 int ecode2 = 0 ;
43549 bool temp3 = false ;
43550 bool temp4 = false ;
43551 int val5 ;
43552 int ecode5 = 0 ;
43553 void *argp6 = 0 ;
43554 int res6 = 0 ;
43555 PyObject * obj0 = 0 ;
43556 PyObject * obj1 = 0 ;
43557 PyObject * obj2 = 0 ;
43558 PyObject * obj3 = 0 ;
43559 PyObject * obj4 = 0 ;
43560 PyObject * obj5 = 0 ;
43561 char * kwnames[] = {
43562 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43563 };
43564
43565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43566 if (obj0) {
43567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43568 if (!SWIG_IsOK(res1)) {
43569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43570 }
43571 arg1 = reinterpret_cast< wxMenu * >(argp1);
43572 }
43573 if (obj1) {
43574 ecode2 = SWIG_AsVal_int(obj1, &val2);
43575 if (!SWIG_IsOK(ecode2)) {
43576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43577 }
43578 arg2 = static_cast< int >(val2);
43579 }
43580 if (obj2) {
43581 {
43582 arg3 = wxString_in_helper(obj2);
43583 if (arg3 == NULL) SWIG_fail;
43584 temp3 = true;
43585 }
43586 }
43587 if (obj3) {
43588 {
43589 arg4 = wxString_in_helper(obj3);
43590 if (arg4 == NULL) SWIG_fail;
43591 temp4 = true;
43592 }
43593 }
43594 if (obj4) {
43595 ecode5 = SWIG_AsVal_int(obj4, &val5);
43596 if (!SWIG_IsOK(ecode5)) {
43597 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43598 }
43599 arg5 = static_cast< wxItemKind >(val5);
43600 }
43601 if (obj5) {
43602 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43603 if (!SWIG_IsOK(res6)) {
43604 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43605 }
43606 arg6 = reinterpret_cast< wxMenu * >(argp6);
43607 }
43608 {
43609 PyThreadState* __tstate = wxPyBeginAllowThreads();
43610 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43611 wxPyEndAllowThreads(__tstate);
43612 if (PyErr_Occurred()) SWIG_fail;
43613 }
43614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
43615 {
43616 if (temp3)
43617 delete arg3;
43618 }
43619 {
43620 if (temp4)
43621 delete arg4;
43622 }
43623 return resultobj;
43624 fail:
43625 {
43626 if (temp3)
43627 delete arg3;
43628 }
43629 {
43630 if (temp4)
43631 delete arg4;
43632 }
43633 return NULL;
43634 }
43635
43636
43637 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43638 PyObject *resultobj = 0;
43639 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43640 void *argp1 = 0 ;
43641 int res1 = 0 ;
43642 PyObject *swig_obj[1] ;
43643
43644 if (!args) SWIG_fail;
43645 swig_obj[0] = args;
43646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43647 if (!SWIG_IsOK(res1)) {
43648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43649 }
43650 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43651 {
43652 PyThreadState* __tstate = wxPyBeginAllowThreads();
43653 delete arg1;
43654
43655 wxPyEndAllowThreads(__tstate);
43656 if (PyErr_Occurred()) SWIG_fail;
43657 }
43658 resultobj = SWIG_Py_Void();
43659 return resultobj;
43660 fail:
43661 return NULL;
43662 }
43663
43664
43665 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43666 PyObject *resultobj = 0;
43667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43668 wxMenu *result = 0 ;
43669 void *argp1 = 0 ;
43670 int res1 = 0 ;
43671 PyObject *swig_obj[1] ;
43672
43673 if (!args) SWIG_fail;
43674 swig_obj[0] = args;
43675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43676 if (!SWIG_IsOK(res1)) {
43677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43678 }
43679 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43680 {
43681 PyThreadState* __tstate = wxPyBeginAllowThreads();
43682 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43683 wxPyEndAllowThreads(__tstate);
43684 if (PyErr_Occurred()) SWIG_fail;
43685 }
43686 {
43687 resultobj = wxPyMake_wxObject(result, 0);
43688 }
43689 return resultobj;
43690 fail:
43691 return NULL;
43692 }
43693
43694
43695 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43696 PyObject *resultobj = 0;
43697 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43698 wxMenu *arg2 = (wxMenu *) 0 ;
43699 void *argp1 = 0 ;
43700 int res1 = 0 ;
43701 void *argp2 = 0 ;
43702 int res2 = 0 ;
43703 PyObject * obj0 = 0 ;
43704 PyObject * obj1 = 0 ;
43705 char * kwnames[] = {
43706 (char *) "self",(char *) "menu", NULL
43707 };
43708
43709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43711 if (!SWIG_IsOK(res1)) {
43712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43713 }
43714 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43715 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43716 if (!SWIG_IsOK(res2)) {
43717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43718 }
43719 arg2 = reinterpret_cast< wxMenu * >(argp2);
43720 {
43721 PyThreadState* __tstate = wxPyBeginAllowThreads();
43722 (arg1)->SetMenu(arg2);
43723 wxPyEndAllowThreads(__tstate);
43724 if (PyErr_Occurred()) SWIG_fail;
43725 }
43726 resultobj = SWIG_Py_Void();
43727 return resultobj;
43728 fail:
43729 return NULL;
43730 }
43731
43732
43733 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43734 PyObject *resultobj = 0;
43735 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43736 int arg2 ;
43737 void *argp1 = 0 ;
43738 int res1 = 0 ;
43739 int val2 ;
43740 int ecode2 = 0 ;
43741 PyObject * obj0 = 0 ;
43742 PyObject * obj1 = 0 ;
43743 char * kwnames[] = {
43744 (char *) "self",(char *) "id", NULL
43745 };
43746
43747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43749 if (!SWIG_IsOK(res1)) {
43750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43751 }
43752 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43753 ecode2 = SWIG_AsVal_int(obj1, &val2);
43754 if (!SWIG_IsOK(ecode2)) {
43755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43756 }
43757 arg2 = static_cast< int >(val2);
43758 {
43759 PyThreadState* __tstate = wxPyBeginAllowThreads();
43760 (arg1)->SetId(arg2);
43761 wxPyEndAllowThreads(__tstate);
43762 if (PyErr_Occurred()) SWIG_fail;
43763 }
43764 resultobj = SWIG_Py_Void();
43765 return resultobj;
43766 fail:
43767 return NULL;
43768 }
43769
43770
43771 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43772 PyObject *resultobj = 0;
43773 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43774 int result;
43775 void *argp1 = 0 ;
43776 int res1 = 0 ;
43777 PyObject *swig_obj[1] ;
43778
43779 if (!args) SWIG_fail;
43780 swig_obj[0] = args;
43781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43782 if (!SWIG_IsOK(res1)) {
43783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43784 }
43785 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43786 {
43787 PyThreadState* __tstate = wxPyBeginAllowThreads();
43788 result = (int)((wxMenuItem const *)arg1)->GetId();
43789 wxPyEndAllowThreads(__tstate);
43790 if (PyErr_Occurred()) SWIG_fail;
43791 }
43792 resultobj = SWIG_From_int(static_cast< int >(result));
43793 return resultobj;
43794 fail:
43795 return NULL;
43796 }
43797
43798
43799 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43800 PyObject *resultobj = 0;
43801 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43802 bool result;
43803 void *argp1 = 0 ;
43804 int res1 = 0 ;
43805 PyObject *swig_obj[1] ;
43806
43807 if (!args) SWIG_fail;
43808 swig_obj[0] = args;
43809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43810 if (!SWIG_IsOK(res1)) {
43811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43812 }
43813 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43814 {
43815 PyThreadState* __tstate = wxPyBeginAllowThreads();
43816 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43817 wxPyEndAllowThreads(__tstate);
43818 if (PyErr_Occurred()) SWIG_fail;
43819 }
43820 {
43821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43822 }
43823 return resultobj;
43824 fail:
43825 return NULL;
43826 }
43827
43828
43829 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43830 PyObject *resultobj = 0;
43831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43832 wxString *arg2 = 0 ;
43833 void *argp1 = 0 ;
43834 int res1 = 0 ;
43835 bool temp2 = false ;
43836 PyObject * obj0 = 0 ;
43837 PyObject * obj1 = 0 ;
43838 char * kwnames[] = {
43839 (char *) "self",(char *) "str", NULL
43840 };
43841
43842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43844 if (!SWIG_IsOK(res1)) {
43845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43846 }
43847 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43848 {
43849 arg2 = wxString_in_helper(obj1);
43850 if (arg2 == NULL) SWIG_fail;
43851 temp2 = true;
43852 }
43853 {
43854 PyThreadState* __tstate = wxPyBeginAllowThreads();
43855 (arg1)->SetText((wxString const &)*arg2);
43856 wxPyEndAllowThreads(__tstate);
43857 if (PyErr_Occurred()) SWIG_fail;
43858 }
43859 resultobj = SWIG_Py_Void();
43860 {
43861 if (temp2)
43862 delete arg2;
43863 }
43864 return resultobj;
43865 fail:
43866 {
43867 if (temp2)
43868 delete arg2;
43869 }
43870 return NULL;
43871 }
43872
43873
43874 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43875 PyObject *resultobj = 0;
43876 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43877 wxString result;
43878 void *argp1 = 0 ;
43879 int res1 = 0 ;
43880 PyObject *swig_obj[1] ;
43881
43882 if (!args) SWIG_fail;
43883 swig_obj[0] = args;
43884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43885 if (!SWIG_IsOK(res1)) {
43886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43887 }
43888 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43889 {
43890 PyThreadState* __tstate = wxPyBeginAllowThreads();
43891 result = ((wxMenuItem const *)arg1)->GetLabel();
43892 wxPyEndAllowThreads(__tstate);
43893 if (PyErr_Occurred()) SWIG_fail;
43894 }
43895 {
43896 #if wxUSE_UNICODE
43897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43898 #else
43899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43900 #endif
43901 }
43902 return resultobj;
43903 fail:
43904 return NULL;
43905 }
43906
43907
43908 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43909 PyObject *resultobj = 0;
43910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43911 wxString *result = 0 ;
43912 void *argp1 = 0 ;
43913 int res1 = 0 ;
43914 PyObject *swig_obj[1] ;
43915
43916 if (!args) SWIG_fail;
43917 swig_obj[0] = args;
43918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43919 if (!SWIG_IsOK(res1)) {
43920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43921 }
43922 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43923 {
43924 PyThreadState* __tstate = wxPyBeginAllowThreads();
43925 {
43926 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43927 result = (wxString *) &_result_ref;
43928 }
43929 wxPyEndAllowThreads(__tstate);
43930 if (PyErr_Occurred()) SWIG_fail;
43931 }
43932 {
43933 #if wxUSE_UNICODE
43934 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43935 #else
43936 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43937 #endif
43938 }
43939 return resultobj;
43940 fail:
43941 return NULL;
43942 }
43943
43944
43945 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43946 PyObject *resultobj = 0;
43947 wxString *arg1 = 0 ;
43948 wxString result;
43949 bool temp1 = false ;
43950 PyObject * obj0 = 0 ;
43951 char * kwnames[] = {
43952 (char *) "text", NULL
43953 };
43954
43955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43956 {
43957 arg1 = wxString_in_helper(obj0);
43958 if (arg1 == NULL) SWIG_fail;
43959 temp1 = true;
43960 }
43961 {
43962 PyThreadState* __tstate = wxPyBeginAllowThreads();
43963 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43964 wxPyEndAllowThreads(__tstate);
43965 if (PyErr_Occurred()) SWIG_fail;
43966 }
43967 {
43968 #if wxUSE_UNICODE
43969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43970 #else
43971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43972 #endif
43973 }
43974 {
43975 if (temp1)
43976 delete arg1;
43977 }
43978 return resultobj;
43979 fail:
43980 {
43981 if (temp1)
43982 delete arg1;
43983 }
43984 return NULL;
43985 }
43986
43987
43988 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43989 PyObject *resultobj = 0;
43990 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43991 wxItemKind result;
43992 void *argp1 = 0 ;
43993 int res1 = 0 ;
43994 PyObject *swig_obj[1] ;
43995
43996 if (!args) SWIG_fail;
43997 swig_obj[0] = args;
43998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43999 if (!SWIG_IsOK(res1)) {
44000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44001 }
44002 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44003 {
44004 PyThreadState* __tstate = wxPyBeginAllowThreads();
44005 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
44006 wxPyEndAllowThreads(__tstate);
44007 if (PyErr_Occurred()) SWIG_fail;
44008 }
44009 resultobj = SWIG_From_int(static_cast< int >(result));
44010 return resultobj;
44011 fail:
44012 return NULL;
44013 }
44014
44015
44016 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44017 PyObject *resultobj = 0;
44018 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44019 wxItemKind arg2 ;
44020 void *argp1 = 0 ;
44021 int res1 = 0 ;
44022 int val2 ;
44023 int ecode2 = 0 ;
44024 PyObject * obj0 = 0 ;
44025 PyObject * obj1 = 0 ;
44026 char * kwnames[] = {
44027 (char *) "self",(char *) "kind", NULL
44028 };
44029
44030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
44031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44032 if (!SWIG_IsOK(res1)) {
44033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44034 }
44035 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44036 ecode2 = SWIG_AsVal_int(obj1, &val2);
44037 if (!SWIG_IsOK(ecode2)) {
44038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
44039 }
44040 arg2 = static_cast< wxItemKind >(val2);
44041 {
44042 PyThreadState* __tstate = wxPyBeginAllowThreads();
44043 (arg1)->SetKind(arg2);
44044 wxPyEndAllowThreads(__tstate);
44045 if (PyErr_Occurred()) SWIG_fail;
44046 }
44047 resultobj = SWIG_Py_Void();
44048 return resultobj;
44049 fail:
44050 return NULL;
44051 }
44052
44053
44054 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44055 PyObject *resultobj = 0;
44056 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44057 bool arg2 ;
44058 void *argp1 = 0 ;
44059 int res1 = 0 ;
44060 bool val2 ;
44061 int ecode2 = 0 ;
44062 PyObject * obj0 = 0 ;
44063 PyObject * obj1 = 0 ;
44064 char * kwnames[] = {
44065 (char *) "self",(char *) "checkable", NULL
44066 };
44067
44068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
44069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44070 if (!SWIG_IsOK(res1)) {
44071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44072 }
44073 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44074 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44075 if (!SWIG_IsOK(ecode2)) {
44076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
44077 }
44078 arg2 = static_cast< bool >(val2);
44079 {
44080 PyThreadState* __tstate = wxPyBeginAllowThreads();
44081 (arg1)->SetCheckable(arg2);
44082 wxPyEndAllowThreads(__tstate);
44083 if (PyErr_Occurred()) SWIG_fail;
44084 }
44085 resultobj = SWIG_Py_Void();
44086 return resultobj;
44087 fail:
44088 return NULL;
44089 }
44090
44091
44092 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44093 PyObject *resultobj = 0;
44094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44095 bool result;
44096 void *argp1 = 0 ;
44097 int res1 = 0 ;
44098 PyObject *swig_obj[1] ;
44099
44100 if (!args) SWIG_fail;
44101 swig_obj[0] = args;
44102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44103 if (!SWIG_IsOK(res1)) {
44104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44105 }
44106 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44107 {
44108 PyThreadState* __tstate = wxPyBeginAllowThreads();
44109 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
44110 wxPyEndAllowThreads(__tstate);
44111 if (PyErr_Occurred()) SWIG_fail;
44112 }
44113 {
44114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44115 }
44116 return resultobj;
44117 fail:
44118 return NULL;
44119 }
44120
44121
44122 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44123 PyObject *resultobj = 0;
44124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44125 bool result;
44126 void *argp1 = 0 ;
44127 int res1 = 0 ;
44128 PyObject *swig_obj[1] ;
44129
44130 if (!args) SWIG_fail;
44131 swig_obj[0] = args;
44132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44133 if (!SWIG_IsOK(res1)) {
44134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44135 }
44136 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44137 {
44138 PyThreadState* __tstate = wxPyBeginAllowThreads();
44139 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
44140 wxPyEndAllowThreads(__tstate);
44141 if (PyErr_Occurred()) SWIG_fail;
44142 }
44143 {
44144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44145 }
44146 return resultobj;
44147 fail:
44148 return NULL;
44149 }
44150
44151
44152 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44153 PyObject *resultobj = 0;
44154 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44155 wxMenu *arg2 = (wxMenu *) 0 ;
44156 void *argp1 = 0 ;
44157 int res1 = 0 ;
44158 void *argp2 = 0 ;
44159 int res2 = 0 ;
44160 PyObject * obj0 = 0 ;
44161 PyObject * obj1 = 0 ;
44162 char * kwnames[] = {
44163 (char *) "self",(char *) "menu", NULL
44164 };
44165
44166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44168 if (!SWIG_IsOK(res1)) {
44169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44170 }
44171 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44173 if (!SWIG_IsOK(res2)) {
44174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
44175 }
44176 arg2 = reinterpret_cast< wxMenu * >(argp2);
44177 {
44178 PyThreadState* __tstate = wxPyBeginAllowThreads();
44179 (arg1)->SetSubMenu(arg2);
44180 wxPyEndAllowThreads(__tstate);
44181 if (PyErr_Occurred()) SWIG_fail;
44182 }
44183 resultobj = SWIG_Py_Void();
44184 return resultobj;
44185 fail:
44186 return NULL;
44187 }
44188
44189
44190 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44191 PyObject *resultobj = 0;
44192 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44193 wxMenu *result = 0 ;
44194 void *argp1 = 0 ;
44195 int res1 = 0 ;
44196 PyObject *swig_obj[1] ;
44197
44198 if (!args) SWIG_fail;
44199 swig_obj[0] = args;
44200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44201 if (!SWIG_IsOK(res1)) {
44202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44203 }
44204 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44205 {
44206 PyThreadState* __tstate = wxPyBeginAllowThreads();
44207 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44208 wxPyEndAllowThreads(__tstate);
44209 if (PyErr_Occurred()) SWIG_fail;
44210 }
44211 {
44212 resultobj = wxPyMake_wxObject(result, 0);
44213 }
44214 return resultobj;
44215 fail:
44216 return NULL;
44217 }
44218
44219
44220 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44221 PyObject *resultobj = 0;
44222 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44223 bool arg2 = (bool) true ;
44224 void *argp1 = 0 ;
44225 int res1 = 0 ;
44226 bool val2 ;
44227 int ecode2 = 0 ;
44228 PyObject * obj0 = 0 ;
44229 PyObject * obj1 = 0 ;
44230 char * kwnames[] = {
44231 (char *) "self",(char *) "enable", NULL
44232 };
44233
44234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44236 if (!SWIG_IsOK(res1)) {
44237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44238 }
44239 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44240 if (obj1) {
44241 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44242 if (!SWIG_IsOK(ecode2)) {
44243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44244 }
44245 arg2 = static_cast< bool >(val2);
44246 }
44247 {
44248 PyThreadState* __tstate = wxPyBeginAllowThreads();
44249 (arg1)->Enable(arg2);
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 resultobj = SWIG_Py_Void();
44254 return resultobj;
44255 fail:
44256 return NULL;
44257 }
44258
44259
44260 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44261 PyObject *resultobj = 0;
44262 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44263 bool result;
44264 void *argp1 = 0 ;
44265 int res1 = 0 ;
44266 PyObject *swig_obj[1] ;
44267
44268 if (!args) SWIG_fail;
44269 swig_obj[0] = args;
44270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44271 if (!SWIG_IsOK(res1)) {
44272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44273 }
44274 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44275 {
44276 PyThreadState* __tstate = wxPyBeginAllowThreads();
44277 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44278 wxPyEndAllowThreads(__tstate);
44279 if (PyErr_Occurred()) SWIG_fail;
44280 }
44281 {
44282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44283 }
44284 return resultobj;
44285 fail:
44286 return NULL;
44287 }
44288
44289
44290 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44291 PyObject *resultobj = 0;
44292 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44293 bool arg2 = (bool) true ;
44294 void *argp1 = 0 ;
44295 int res1 = 0 ;
44296 bool val2 ;
44297 int ecode2 = 0 ;
44298 PyObject * obj0 = 0 ;
44299 PyObject * obj1 = 0 ;
44300 char * kwnames[] = {
44301 (char *) "self",(char *) "check", NULL
44302 };
44303
44304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44306 if (!SWIG_IsOK(res1)) {
44307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44308 }
44309 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44310 if (obj1) {
44311 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44312 if (!SWIG_IsOK(ecode2)) {
44313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44314 }
44315 arg2 = static_cast< bool >(val2);
44316 }
44317 {
44318 PyThreadState* __tstate = wxPyBeginAllowThreads();
44319 (arg1)->Check(arg2);
44320 wxPyEndAllowThreads(__tstate);
44321 if (PyErr_Occurred()) SWIG_fail;
44322 }
44323 resultobj = SWIG_Py_Void();
44324 return resultobj;
44325 fail:
44326 return NULL;
44327 }
44328
44329
44330 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44331 PyObject *resultobj = 0;
44332 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44333 bool result;
44334 void *argp1 = 0 ;
44335 int res1 = 0 ;
44336 PyObject *swig_obj[1] ;
44337
44338 if (!args) SWIG_fail;
44339 swig_obj[0] = args;
44340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44341 if (!SWIG_IsOK(res1)) {
44342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44343 }
44344 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44345 {
44346 PyThreadState* __tstate = wxPyBeginAllowThreads();
44347 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44348 wxPyEndAllowThreads(__tstate);
44349 if (PyErr_Occurred()) SWIG_fail;
44350 }
44351 {
44352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44353 }
44354 return resultobj;
44355 fail:
44356 return NULL;
44357 }
44358
44359
44360 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44361 PyObject *resultobj = 0;
44362 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44363 void *argp1 = 0 ;
44364 int res1 = 0 ;
44365 PyObject *swig_obj[1] ;
44366
44367 if (!args) SWIG_fail;
44368 swig_obj[0] = args;
44369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44370 if (!SWIG_IsOK(res1)) {
44371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44372 }
44373 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44374 {
44375 PyThreadState* __tstate = wxPyBeginAllowThreads();
44376 (arg1)->Toggle();
44377 wxPyEndAllowThreads(__tstate);
44378 if (PyErr_Occurred()) SWIG_fail;
44379 }
44380 resultobj = SWIG_Py_Void();
44381 return resultobj;
44382 fail:
44383 return NULL;
44384 }
44385
44386
44387 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44388 PyObject *resultobj = 0;
44389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44390 wxString *arg2 = 0 ;
44391 void *argp1 = 0 ;
44392 int res1 = 0 ;
44393 bool temp2 = false ;
44394 PyObject * obj0 = 0 ;
44395 PyObject * obj1 = 0 ;
44396 char * kwnames[] = {
44397 (char *) "self",(char *) "str", NULL
44398 };
44399
44400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44402 if (!SWIG_IsOK(res1)) {
44403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44404 }
44405 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44406 {
44407 arg2 = wxString_in_helper(obj1);
44408 if (arg2 == NULL) SWIG_fail;
44409 temp2 = true;
44410 }
44411 {
44412 PyThreadState* __tstate = wxPyBeginAllowThreads();
44413 (arg1)->SetHelp((wxString const &)*arg2);
44414 wxPyEndAllowThreads(__tstate);
44415 if (PyErr_Occurred()) SWIG_fail;
44416 }
44417 resultobj = SWIG_Py_Void();
44418 {
44419 if (temp2)
44420 delete arg2;
44421 }
44422 return resultobj;
44423 fail:
44424 {
44425 if (temp2)
44426 delete arg2;
44427 }
44428 return NULL;
44429 }
44430
44431
44432 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44433 PyObject *resultobj = 0;
44434 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44435 wxString *result = 0 ;
44436 void *argp1 = 0 ;
44437 int res1 = 0 ;
44438 PyObject *swig_obj[1] ;
44439
44440 if (!args) SWIG_fail;
44441 swig_obj[0] = args;
44442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44443 if (!SWIG_IsOK(res1)) {
44444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44445 }
44446 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44447 {
44448 PyThreadState* __tstate = wxPyBeginAllowThreads();
44449 {
44450 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44451 result = (wxString *) &_result_ref;
44452 }
44453 wxPyEndAllowThreads(__tstate);
44454 if (PyErr_Occurred()) SWIG_fail;
44455 }
44456 {
44457 #if wxUSE_UNICODE
44458 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44459 #else
44460 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44461 #endif
44462 }
44463 return resultobj;
44464 fail:
44465 return NULL;
44466 }
44467
44468
44469 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44470 PyObject *resultobj = 0;
44471 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44472 wxAcceleratorEntry *result = 0 ;
44473 void *argp1 = 0 ;
44474 int res1 = 0 ;
44475 PyObject *swig_obj[1] ;
44476
44477 if (!args) SWIG_fail;
44478 swig_obj[0] = args;
44479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44480 if (!SWIG_IsOK(res1)) {
44481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44482 }
44483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44484 {
44485 PyThreadState* __tstate = wxPyBeginAllowThreads();
44486 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44487 wxPyEndAllowThreads(__tstate);
44488 if (PyErr_Occurred()) SWIG_fail;
44489 }
44490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44491 return resultobj;
44492 fail:
44493 return NULL;
44494 }
44495
44496
44497 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44498 PyObject *resultobj = 0;
44499 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44500 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44501 void *argp1 = 0 ;
44502 int res1 = 0 ;
44503 void *argp2 = 0 ;
44504 int res2 = 0 ;
44505 PyObject * obj0 = 0 ;
44506 PyObject * obj1 = 0 ;
44507 char * kwnames[] = {
44508 (char *) "self",(char *) "accel", NULL
44509 };
44510
44511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44513 if (!SWIG_IsOK(res1)) {
44514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44515 }
44516 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44518 if (!SWIG_IsOK(res2)) {
44519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44520 }
44521 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44522 {
44523 PyThreadState* __tstate = wxPyBeginAllowThreads();
44524 (arg1)->SetAccel(arg2);
44525 wxPyEndAllowThreads(__tstate);
44526 if (PyErr_Occurred()) SWIG_fail;
44527 }
44528 resultobj = SWIG_Py_Void();
44529 return resultobj;
44530 fail:
44531 return NULL;
44532 }
44533
44534
44535 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44536 PyObject *resultobj = 0;
44537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44538 wxBitmap *arg2 = 0 ;
44539 void *argp1 = 0 ;
44540 int res1 = 0 ;
44541 void *argp2 = 0 ;
44542 int res2 = 0 ;
44543 PyObject * obj0 = 0 ;
44544 PyObject * obj1 = 0 ;
44545 char * kwnames[] = {
44546 (char *) "self",(char *) "bitmap", NULL
44547 };
44548
44549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44551 if (!SWIG_IsOK(res1)) {
44552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44553 }
44554 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44555 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44556 if (!SWIG_IsOK(res2)) {
44557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44558 }
44559 if (!argp2) {
44560 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44561 }
44562 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44563 {
44564 PyThreadState* __tstate = wxPyBeginAllowThreads();
44565 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44566 wxPyEndAllowThreads(__tstate);
44567 if (PyErr_Occurred()) SWIG_fail;
44568 }
44569 resultobj = SWIG_Py_Void();
44570 return resultobj;
44571 fail:
44572 return NULL;
44573 }
44574
44575
44576 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44577 PyObject *resultobj = 0;
44578 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44579 wxBitmap *result = 0 ;
44580 void *argp1 = 0 ;
44581 int res1 = 0 ;
44582 PyObject *swig_obj[1] ;
44583
44584 if (!args) SWIG_fail;
44585 swig_obj[0] = args;
44586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44587 if (!SWIG_IsOK(res1)) {
44588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44589 }
44590 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44591 {
44592 PyThreadState* __tstate = wxPyBeginAllowThreads();
44593 {
44594 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44595 result = (wxBitmap *) &_result_ref;
44596 }
44597 wxPyEndAllowThreads(__tstate);
44598 if (PyErr_Occurred()) SWIG_fail;
44599 }
44600 {
44601 wxBitmap* resultptr = new wxBitmap(*result);
44602 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44603 }
44604 return resultobj;
44605 fail:
44606 return NULL;
44607 }
44608
44609
44610 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44611 PyObject *resultobj = 0;
44612 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44613 wxFont *arg2 = 0 ;
44614 void *argp1 = 0 ;
44615 int res1 = 0 ;
44616 void *argp2 = 0 ;
44617 int res2 = 0 ;
44618 PyObject * obj0 = 0 ;
44619 PyObject * obj1 = 0 ;
44620 char * kwnames[] = {
44621 (char *) "self",(char *) "font", NULL
44622 };
44623
44624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44626 if (!SWIG_IsOK(res1)) {
44627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44628 }
44629 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44631 if (!SWIG_IsOK(res2)) {
44632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44633 }
44634 if (!argp2) {
44635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44636 }
44637 arg2 = reinterpret_cast< wxFont * >(argp2);
44638 {
44639 PyThreadState* __tstate = wxPyBeginAllowThreads();
44640 (arg1)->SetFont((wxFont const &)*arg2);
44641 wxPyEndAllowThreads(__tstate);
44642 if (PyErr_Occurred()) SWIG_fail;
44643 }
44644 resultobj = SWIG_Py_Void();
44645 return resultobj;
44646 fail:
44647 return NULL;
44648 }
44649
44650
44651 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44652 PyObject *resultobj = 0;
44653 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44654 wxFont result;
44655 void *argp1 = 0 ;
44656 int res1 = 0 ;
44657 PyObject *swig_obj[1] ;
44658
44659 if (!args) SWIG_fail;
44660 swig_obj[0] = args;
44661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44662 if (!SWIG_IsOK(res1)) {
44663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44664 }
44665 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44666 {
44667 PyThreadState* __tstate = wxPyBeginAllowThreads();
44668 result = (arg1)->GetFont();
44669 wxPyEndAllowThreads(__tstate);
44670 if (PyErr_Occurred()) SWIG_fail;
44671 }
44672 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44673 return resultobj;
44674 fail:
44675 return NULL;
44676 }
44677
44678
44679 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44680 PyObject *resultobj = 0;
44681 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44682 wxColour *arg2 = 0 ;
44683 void *argp1 = 0 ;
44684 int res1 = 0 ;
44685 wxColour temp2 ;
44686 PyObject * obj0 = 0 ;
44687 PyObject * obj1 = 0 ;
44688 char * kwnames[] = {
44689 (char *) "self",(char *) "colText", NULL
44690 };
44691
44692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44694 if (!SWIG_IsOK(res1)) {
44695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44696 }
44697 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44698 {
44699 arg2 = &temp2;
44700 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44701 }
44702 {
44703 PyThreadState* __tstate = wxPyBeginAllowThreads();
44704 (arg1)->SetTextColour((wxColour const &)*arg2);
44705 wxPyEndAllowThreads(__tstate);
44706 if (PyErr_Occurred()) SWIG_fail;
44707 }
44708 resultobj = SWIG_Py_Void();
44709 return resultobj;
44710 fail:
44711 return NULL;
44712 }
44713
44714
44715 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44716 PyObject *resultobj = 0;
44717 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44718 wxColour result;
44719 void *argp1 = 0 ;
44720 int res1 = 0 ;
44721 PyObject *swig_obj[1] ;
44722
44723 if (!args) SWIG_fail;
44724 swig_obj[0] = args;
44725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44726 if (!SWIG_IsOK(res1)) {
44727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44728 }
44729 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44730 {
44731 PyThreadState* __tstate = wxPyBeginAllowThreads();
44732 result = (arg1)->GetTextColour();
44733 wxPyEndAllowThreads(__tstate);
44734 if (PyErr_Occurred()) SWIG_fail;
44735 }
44736 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44737 return resultobj;
44738 fail:
44739 return NULL;
44740 }
44741
44742
44743 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44744 PyObject *resultobj = 0;
44745 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44746 wxColour *arg2 = 0 ;
44747 void *argp1 = 0 ;
44748 int res1 = 0 ;
44749 wxColour temp2 ;
44750 PyObject * obj0 = 0 ;
44751 PyObject * obj1 = 0 ;
44752 char * kwnames[] = {
44753 (char *) "self",(char *) "colBack", NULL
44754 };
44755
44756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44758 if (!SWIG_IsOK(res1)) {
44759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44760 }
44761 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44762 {
44763 arg2 = &temp2;
44764 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44765 }
44766 {
44767 PyThreadState* __tstate = wxPyBeginAllowThreads();
44768 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
44769 wxPyEndAllowThreads(__tstate);
44770 if (PyErr_Occurred()) SWIG_fail;
44771 }
44772 resultobj = SWIG_Py_Void();
44773 return resultobj;
44774 fail:
44775 return NULL;
44776 }
44777
44778
44779 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44780 PyObject *resultobj = 0;
44781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44782 wxColour result;
44783 void *argp1 = 0 ;
44784 int res1 = 0 ;
44785 PyObject *swig_obj[1] ;
44786
44787 if (!args) SWIG_fail;
44788 swig_obj[0] = args;
44789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44790 if (!SWIG_IsOK(res1)) {
44791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44792 }
44793 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44794 {
44795 PyThreadState* __tstate = wxPyBeginAllowThreads();
44796 result = (arg1)->GetBackgroundColour();
44797 wxPyEndAllowThreads(__tstate);
44798 if (PyErr_Occurred()) SWIG_fail;
44799 }
44800 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44801 return resultobj;
44802 fail:
44803 return NULL;
44804 }
44805
44806
44807 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44808 PyObject *resultobj = 0;
44809 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44810 wxBitmap *arg2 = 0 ;
44811 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44812 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44813 void *argp1 = 0 ;
44814 int res1 = 0 ;
44815 void *argp2 = 0 ;
44816 int res2 = 0 ;
44817 void *argp3 = 0 ;
44818 int res3 = 0 ;
44819 PyObject * obj0 = 0 ;
44820 PyObject * obj1 = 0 ;
44821 PyObject * obj2 = 0 ;
44822 char * kwnames[] = {
44823 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44824 };
44825
44826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44828 if (!SWIG_IsOK(res1)) {
44829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44830 }
44831 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44832 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44833 if (!SWIG_IsOK(res2)) {
44834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44835 }
44836 if (!argp2) {
44837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44838 }
44839 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44840 if (obj2) {
44841 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44842 if (!SWIG_IsOK(res3)) {
44843 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44844 }
44845 if (!argp3) {
44846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44847 }
44848 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44849 }
44850 {
44851 PyThreadState* __tstate = wxPyBeginAllowThreads();
44852 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44853 wxPyEndAllowThreads(__tstate);
44854 if (PyErr_Occurred()) SWIG_fail;
44855 }
44856 resultobj = SWIG_Py_Void();
44857 return resultobj;
44858 fail:
44859 return NULL;
44860 }
44861
44862
44863 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44864 PyObject *resultobj = 0;
44865 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44866 wxBitmap *arg2 = 0 ;
44867 void *argp1 = 0 ;
44868 int res1 = 0 ;
44869 void *argp2 = 0 ;
44870 int res2 = 0 ;
44871 PyObject * obj0 = 0 ;
44872 PyObject * obj1 = 0 ;
44873 char * kwnames[] = {
44874 (char *) "self",(char *) "bmpDisabled", NULL
44875 };
44876
44877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44879 if (!SWIG_IsOK(res1)) {
44880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44881 }
44882 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44884 if (!SWIG_IsOK(res2)) {
44885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44886 }
44887 if (!argp2) {
44888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44889 }
44890 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44891 {
44892 PyThreadState* __tstate = wxPyBeginAllowThreads();
44893 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
44894 wxPyEndAllowThreads(__tstate);
44895 if (PyErr_Occurred()) SWIG_fail;
44896 }
44897 resultobj = SWIG_Py_Void();
44898 return resultobj;
44899 fail:
44900 return NULL;
44901 }
44902
44903
44904 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44905 PyObject *resultobj = 0;
44906 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44907 wxBitmap *result = 0 ;
44908 void *argp1 = 0 ;
44909 int res1 = 0 ;
44910 PyObject *swig_obj[1] ;
44911
44912 if (!args) SWIG_fail;
44913 swig_obj[0] = args;
44914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44915 if (!SWIG_IsOK(res1)) {
44916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44917 }
44918 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44919 {
44920 PyThreadState* __tstate = wxPyBeginAllowThreads();
44921 {
44922 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
44923 result = (wxBitmap *) &_result_ref;
44924 }
44925 wxPyEndAllowThreads(__tstate);
44926 if (PyErr_Occurred()) SWIG_fail;
44927 }
44928 {
44929 wxBitmap* resultptr = new wxBitmap(*result);
44930 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44931 }
44932 return resultobj;
44933 fail:
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44939 PyObject *resultobj = 0;
44940 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44941 int arg2 ;
44942 void *argp1 = 0 ;
44943 int res1 = 0 ;
44944 int val2 ;
44945 int ecode2 = 0 ;
44946 PyObject * obj0 = 0 ;
44947 PyObject * obj1 = 0 ;
44948 char * kwnames[] = {
44949 (char *) "self",(char *) "nWidth", NULL
44950 };
44951
44952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44954 if (!SWIG_IsOK(res1)) {
44955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44956 }
44957 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44958 ecode2 = SWIG_AsVal_int(obj1, &val2);
44959 if (!SWIG_IsOK(ecode2)) {
44960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44961 }
44962 arg2 = static_cast< int >(val2);
44963 {
44964 PyThreadState* __tstate = wxPyBeginAllowThreads();
44965 (arg1)->SetMarginWidth(arg2);
44966 wxPyEndAllowThreads(__tstate);
44967 if (PyErr_Occurred()) SWIG_fail;
44968 }
44969 resultobj = SWIG_Py_Void();
44970 return resultobj;
44971 fail:
44972 return NULL;
44973 }
44974
44975
44976 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44977 PyObject *resultobj = 0;
44978 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44979 int result;
44980 void *argp1 = 0 ;
44981 int res1 = 0 ;
44982 PyObject *swig_obj[1] ;
44983
44984 if (!args) SWIG_fail;
44985 swig_obj[0] = args;
44986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44987 if (!SWIG_IsOK(res1)) {
44988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44989 }
44990 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44991 {
44992 PyThreadState* __tstate = wxPyBeginAllowThreads();
44993 result = (int)(arg1)->GetMarginWidth();
44994 wxPyEndAllowThreads(__tstate);
44995 if (PyErr_Occurred()) SWIG_fail;
44996 }
44997 resultobj = SWIG_From_int(static_cast< int >(result));
44998 return resultobj;
44999 fail:
45000 return NULL;
45001 }
45002
45003
45004 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45005 PyObject *resultobj = 0;
45006 int result;
45007
45008 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
45009 {
45010 PyThreadState* __tstate = wxPyBeginAllowThreads();
45011 result = (int)wxMenuItem::GetDefaultMarginWidth();
45012 wxPyEndAllowThreads(__tstate);
45013 if (PyErr_Occurred()) SWIG_fail;
45014 }
45015 resultobj = SWIG_From_int(static_cast< int >(result));
45016 return resultobj;
45017 fail:
45018 return NULL;
45019 }
45020
45021
45022 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45023 PyObject *resultobj = 0;
45024 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45025 bool result;
45026 void *argp1 = 0 ;
45027 int res1 = 0 ;
45028 PyObject *swig_obj[1] ;
45029
45030 if (!args) SWIG_fail;
45031 swig_obj[0] = args;
45032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45033 if (!SWIG_IsOK(res1)) {
45034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45035 }
45036 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45037 {
45038 PyThreadState* __tstate = wxPyBeginAllowThreads();
45039 result = (bool)(arg1)->IsOwnerDrawn();
45040 wxPyEndAllowThreads(__tstate);
45041 if (PyErr_Occurred()) SWIG_fail;
45042 }
45043 {
45044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45045 }
45046 return resultobj;
45047 fail:
45048 return NULL;
45049 }
45050
45051
45052 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45053 PyObject *resultobj = 0;
45054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45055 bool arg2 = (bool) true ;
45056 void *argp1 = 0 ;
45057 int res1 = 0 ;
45058 bool val2 ;
45059 int ecode2 = 0 ;
45060 PyObject * obj0 = 0 ;
45061 PyObject * obj1 = 0 ;
45062 char * kwnames[] = {
45063 (char *) "self",(char *) "ownerDrawn", NULL
45064 };
45065
45066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
45067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45068 if (!SWIG_IsOK(res1)) {
45069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45070 }
45071 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45072 if (obj1) {
45073 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45074 if (!SWIG_IsOK(ecode2)) {
45075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
45076 }
45077 arg2 = static_cast< bool >(val2);
45078 }
45079 {
45080 PyThreadState* __tstate = wxPyBeginAllowThreads();
45081 (arg1)->SetOwnerDrawn(arg2);
45082 wxPyEndAllowThreads(__tstate);
45083 if (PyErr_Occurred()) SWIG_fail;
45084 }
45085 resultobj = SWIG_Py_Void();
45086 return resultobj;
45087 fail:
45088 return NULL;
45089 }
45090
45091
45092 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45093 PyObject *resultobj = 0;
45094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45095 void *argp1 = 0 ;
45096 int res1 = 0 ;
45097 PyObject *swig_obj[1] ;
45098
45099 if (!args) SWIG_fail;
45100 swig_obj[0] = args;
45101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45102 if (!SWIG_IsOK(res1)) {
45103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45104 }
45105 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45106 {
45107 PyThreadState* __tstate = wxPyBeginAllowThreads();
45108 (arg1)->ResetOwnerDrawn();
45109 wxPyEndAllowThreads(__tstate);
45110 if (PyErr_Occurred()) SWIG_fail;
45111 }
45112 resultobj = SWIG_Py_Void();
45113 return resultobj;
45114 fail:
45115 return NULL;
45116 }
45117
45118
45119 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45120 PyObject *obj;
45121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45122 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
45123 return SWIG_Py_Void();
45124 }
45125
45126 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45127 return SWIG_Python_InitShadowInstance(args);
45128 }
45129
45130 SWIGINTERN int ControlNameStr_set(PyObject *) {
45131 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
45132 return 1;
45133 }
45134
45135
45136 SWIGINTERN PyObject *ControlNameStr_get(void) {
45137 PyObject *pyobj = 0;
45138
45139 {
45140 #if wxUSE_UNICODE
45141 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45142 #else
45143 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45144 #endif
45145 }
45146 return pyobj;
45147 }
45148
45149
45150 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45151 PyObject *resultobj = 0;
45152 wxWindow *arg1 = (wxWindow *) 0 ;
45153 int arg2 = (int) -1 ;
45154 wxPoint const &arg3_defvalue = wxDefaultPosition ;
45155 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
45156 wxSize const &arg4_defvalue = wxDefaultSize ;
45157 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
45158 long arg5 = (long) 0 ;
45159 wxValidator const &arg6_defvalue = wxDefaultValidator ;
45160 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
45161 wxString const &arg7_defvalue = wxPyControlNameStr ;
45162 wxString *arg7 = (wxString *) &arg7_defvalue ;
45163 wxControl *result = 0 ;
45164 void *argp1 = 0 ;
45165 int res1 = 0 ;
45166 int val2 ;
45167 int ecode2 = 0 ;
45168 wxPoint temp3 ;
45169 wxSize temp4 ;
45170 long val5 ;
45171 int ecode5 = 0 ;
45172 void *argp6 = 0 ;
45173 int res6 = 0 ;
45174 bool temp7 = false ;
45175 PyObject * obj0 = 0 ;
45176 PyObject * obj1 = 0 ;
45177 PyObject * obj2 = 0 ;
45178 PyObject * obj3 = 0 ;
45179 PyObject * obj4 = 0 ;
45180 PyObject * obj5 = 0 ;
45181 PyObject * obj6 = 0 ;
45182 char * kwnames[] = {
45183 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45184 };
45185
45186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45188 if (!SWIG_IsOK(res1)) {
45189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45190 }
45191 arg1 = reinterpret_cast< wxWindow * >(argp1);
45192 if (obj1) {
45193 ecode2 = SWIG_AsVal_int(obj1, &val2);
45194 if (!SWIG_IsOK(ecode2)) {
45195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45196 }
45197 arg2 = static_cast< int >(val2);
45198 }
45199 if (obj2) {
45200 {
45201 arg3 = &temp3;
45202 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45203 }
45204 }
45205 if (obj3) {
45206 {
45207 arg4 = &temp4;
45208 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45209 }
45210 }
45211 if (obj4) {
45212 ecode5 = SWIG_AsVal_long(obj4, &val5);
45213 if (!SWIG_IsOK(ecode5)) {
45214 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45215 }
45216 arg5 = static_cast< long >(val5);
45217 }
45218 if (obj5) {
45219 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45220 if (!SWIG_IsOK(res6)) {
45221 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45222 }
45223 if (!argp6) {
45224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45225 }
45226 arg6 = reinterpret_cast< wxValidator * >(argp6);
45227 }
45228 if (obj6) {
45229 {
45230 arg7 = wxString_in_helper(obj6);
45231 if (arg7 == NULL) SWIG_fail;
45232 temp7 = true;
45233 }
45234 }
45235 {
45236 if (!wxPyCheckForApp()) SWIG_fail;
45237 PyThreadState* __tstate = wxPyBeginAllowThreads();
45238 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45239 wxPyEndAllowThreads(__tstate);
45240 if (PyErr_Occurred()) SWIG_fail;
45241 }
45242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45243 {
45244 if (temp7)
45245 delete arg7;
45246 }
45247 return resultobj;
45248 fail:
45249 {
45250 if (temp7)
45251 delete arg7;
45252 }
45253 return NULL;
45254 }
45255
45256
45257 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45258 PyObject *resultobj = 0;
45259 wxControl *result = 0 ;
45260
45261 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45262 {
45263 if (!wxPyCheckForApp()) SWIG_fail;
45264 PyThreadState* __tstate = wxPyBeginAllowThreads();
45265 result = (wxControl *)new wxControl();
45266 wxPyEndAllowThreads(__tstate);
45267 if (PyErr_Occurred()) SWIG_fail;
45268 }
45269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45270 return resultobj;
45271 fail:
45272 return NULL;
45273 }
45274
45275
45276 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45277 PyObject *resultobj = 0;
45278 wxControl *arg1 = (wxControl *) 0 ;
45279 wxWindow *arg2 = (wxWindow *) 0 ;
45280 int arg3 = (int) -1 ;
45281 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45282 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45283 wxSize const &arg5_defvalue = wxDefaultSize ;
45284 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45285 long arg6 = (long) 0 ;
45286 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45287 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45288 wxString const &arg8_defvalue = wxPyControlNameStr ;
45289 wxString *arg8 = (wxString *) &arg8_defvalue ;
45290 bool result;
45291 void *argp1 = 0 ;
45292 int res1 = 0 ;
45293 void *argp2 = 0 ;
45294 int res2 = 0 ;
45295 int val3 ;
45296 int ecode3 = 0 ;
45297 wxPoint temp4 ;
45298 wxSize temp5 ;
45299 long val6 ;
45300 int ecode6 = 0 ;
45301 void *argp7 = 0 ;
45302 int res7 = 0 ;
45303 bool temp8 = false ;
45304 PyObject * obj0 = 0 ;
45305 PyObject * obj1 = 0 ;
45306 PyObject * obj2 = 0 ;
45307 PyObject * obj3 = 0 ;
45308 PyObject * obj4 = 0 ;
45309 PyObject * obj5 = 0 ;
45310 PyObject * obj6 = 0 ;
45311 PyObject * obj7 = 0 ;
45312 char * kwnames[] = {
45313 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45314 };
45315
45316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45318 if (!SWIG_IsOK(res1)) {
45319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45320 }
45321 arg1 = reinterpret_cast< wxControl * >(argp1);
45322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45323 if (!SWIG_IsOK(res2)) {
45324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45325 }
45326 arg2 = reinterpret_cast< wxWindow * >(argp2);
45327 if (obj2) {
45328 ecode3 = SWIG_AsVal_int(obj2, &val3);
45329 if (!SWIG_IsOK(ecode3)) {
45330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45331 }
45332 arg3 = static_cast< int >(val3);
45333 }
45334 if (obj3) {
45335 {
45336 arg4 = &temp4;
45337 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45338 }
45339 }
45340 if (obj4) {
45341 {
45342 arg5 = &temp5;
45343 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45344 }
45345 }
45346 if (obj5) {
45347 ecode6 = SWIG_AsVal_long(obj5, &val6);
45348 if (!SWIG_IsOK(ecode6)) {
45349 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45350 }
45351 arg6 = static_cast< long >(val6);
45352 }
45353 if (obj6) {
45354 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45355 if (!SWIG_IsOK(res7)) {
45356 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45357 }
45358 if (!argp7) {
45359 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45360 }
45361 arg7 = reinterpret_cast< wxValidator * >(argp7);
45362 }
45363 if (obj7) {
45364 {
45365 arg8 = wxString_in_helper(obj7);
45366 if (arg8 == NULL) SWIG_fail;
45367 temp8 = true;
45368 }
45369 }
45370 {
45371 PyThreadState* __tstate = wxPyBeginAllowThreads();
45372 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45373 wxPyEndAllowThreads(__tstate);
45374 if (PyErr_Occurred()) SWIG_fail;
45375 }
45376 {
45377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45378 }
45379 {
45380 if (temp8)
45381 delete arg8;
45382 }
45383 return resultobj;
45384 fail:
45385 {
45386 if (temp8)
45387 delete arg8;
45388 }
45389 return NULL;
45390 }
45391
45392
45393 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45394 PyObject *resultobj = 0;
45395 wxControl *arg1 = (wxControl *) 0 ;
45396 int result;
45397 void *argp1 = 0 ;
45398 int res1 = 0 ;
45399 PyObject *swig_obj[1] ;
45400
45401 if (!args) SWIG_fail;
45402 swig_obj[0] = args;
45403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45404 if (!SWIG_IsOK(res1)) {
45405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45406 }
45407 arg1 = reinterpret_cast< wxControl * >(argp1);
45408 {
45409 PyThreadState* __tstate = wxPyBeginAllowThreads();
45410 result = (int)((wxControl const *)arg1)->GetAlignment();
45411 wxPyEndAllowThreads(__tstate);
45412 if (PyErr_Occurred()) SWIG_fail;
45413 }
45414 resultobj = SWIG_From_int(static_cast< int >(result));
45415 return resultobj;
45416 fail:
45417 return NULL;
45418 }
45419
45420
45421 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45422 PyObject *resultobj = 0;
45423 wxControl *arg1 = (wxControl *) 0 ;
45424 wxString result;
45425 void *argp1 = 0 ;
45426 int res1 = 0 ;
45427 PyObject *swig_obj[1] ;
45428
45429 if (!args) SWIG_fail;
45430 swig_obj[0] = args;
45431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45432 if (!SWIG_IsOK(res1)) {
45433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45434 }
45435 arg1 = reinterpret_cast< wxControl * >(argp1);
45436 {
45437 PyThreadState* __tstate = wxPyBeginAllowThreads();
45438 result = ((wxControl const *)arg1)->GetLabelText();
45439 wxPyEndAllowThreads(__tstate);
45440 if (PyErr_Occurred()) SWIG_fail;
45441 }
45442 {
45443 #if wxUSE_UNICODE
45444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45445 #else
45446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45447 #endif
45448 }
45449 return resultobj;
45450 fail:
45451 return NULL;
45452 }
45453
45454
45455 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45456 PyObject *resultobj = 0;
45457 wxControl *arg1 = (wxControl *) 0 ;
45458 wxCommandEvent *arg2 = 0 ;
45459 void *argp1 = 0 ;
45460 int res1 = 0 ;
45461 void *argp2 = 0 ;
45462 int res2 = 0 ;
45463 PyObject * obj0 = 0 ;
45464 PyObject * obj1 = 0 ;
45465 char * kwnames[] = {
45466 (char *) "self",(char *) "event", NULL
45467 };
45468
45469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45471 if (!SWIG_IsOK(res1)) {
45472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45473 }
45474 arg1 = reinterpret_cast< wxControl * >(argp1);
45475 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45476 if (!SWIG_IsOK(res2)) {
45477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45478 }
45479 if (!argp2) {
45480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45481 }
45482 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45483 {
45484 PyThreadState* __tstate = wxPyBeginAllowThreads();
45485 (arg1)->Command(*arg2);
45486 wxPyEndAllowThreads(__tstate);
45487 if (PyErr_Occurred()) SWIG_fail;
45488 }
45489 resultobj = SWIG_Py_Void();
45490 return resultobj;
45491 fail:
45492 return NULL;
45493 }
45494
45495
45496 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45497 PyObject *resultobj = 0;
45498 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45499 SwigValueWrapper<wxVisualAttributes > result;
45500 int val1 ;
45501 int ecode1 = 0 ;
45502 PyObject * obj0 = 0 ;
45503 char * kwnames[] = {
45504 (char *) "variant", NULL
45505 };
45506
45507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45508 if (obj0) {
45509 ecode1 = SWIG_AsVal_int(obj0, &val1);
45510 if (!SWIG_IsOK(ecode1)) {
45511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45512 }
45513 arg1 = static_cast< wxWindowVariant >(val1);
45514 }
45515 {
45516 if (!wxPyCheckForApp()) SWIG_fail;
45517 PyThreadState* __tstate = wxPyBeginAllowThreads();
45518 result = wxControl::GetClassDefaultAttributes(arg1);
45519 wxPyEndAllowThreads(__tstate);
45520 if (PyErr_Occurred()) SWIG_fail;
45521 }
45522 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45523 return resultobj;
45524 fail:
45525 return NULL;
45526 }
45527
45528
45529 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45530 PyObject *obj;
45531 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45532 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45533 return SWIG_Py_Void();
45534 }
45535
45536 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45537 return SWIG_Python_InitShadowInstance(args);
45538 }
45539
45540 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45541 PyObject *resultobj = 0;
45542 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45543 wxString *arg2 = 0 ;
45544 PyObject *arg3 = (PyObject *) NULL ;
45545 int result;
45546 void *argp1 = 0 ;
45547 int res1 = 0 ;
45548 bool temp2 = false ;
45549 PyObject * obj0 = 0 ;
45550 PyObject * obj1 = 0 ;
45551 PyObject * obj2 = 0 ;
45552 char * kwnames[] = {
45553 (char *) "self",(char *) "item",(char *) "clientData", NULL
45554 };
45555
45556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45558 if (!SWIG_IsOK(res1)) {
45559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45560 }
45561 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45562 {
45563 arg2 = wxString_in_helper(obj1);
45564 if (arg2 == NULL) SWIG_fail;
45565 temp2 = true;
45566 }
45567 if (obj2) {
45568 arg3 = obj2;
45569 }
45570 {
45571 PyThreadState* __tstate = wxPyBeginAllowThreads();
45572 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45573 wxPyEndAllowThreads(__tstate);
45574 if (PyErr_Occurred()) SWIG_fail;
45575 }
45576 resultobj = SWIG_From_int(static_cast< int >(result));
45577 {
45578 if (temp2)
45579 delete arg2;
45580 }
45581 return resultobj;
45582 fail:
45583 {
45584 if (temp2)
45585 delete arg2;
45586 }
45587 return NULL;
45588 }
45589
45590
45591 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45592 PyObject *resultobj = 0;
45593 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45594 wxArrayString *arg2 = 0 ;
45595 void *argp1 = 0 ;
45596 int res1 = 0 ;
45597 bool temp2 = false ;
45598 PyObject * obj0 = 0 ;
45599 PyObject * obj1 = 0 ;
45600 char * kwnames[] = {
45601 (char *) "self",(char *) "strings", NULL
45602 };
45603
45604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45606 if (!SWIG_IsOK(res1)) {
45607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45608 }
45609 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45610 {
45611 if (! PySequence_Check(obj1)) {
45612 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45613 SWIG_fail;
45614 }
45615 arg2 = new wxArrayString;
45616 temp2 = true;
45617 int i, len=PySequence_Length(obj1);
45618 for (i=0; i<len; i++) {
45619 PyObject* item = PySequence_GetItem(obj1, i);
45620 wxString* s = wxString_in_helper(item);
45621 if (PyErr_Occurred()) SWIG_fail;
45622 arg2->Add(*s);
45623 delete s;
45624 Py_DECREF(item);
45625 }
45626 }
45627 {
45628 PyThreadState* __tstate = wxPyBeginAllowThreads();
45629 (arg1)->Append((wxArrayString const &)*arg2);
45630 wxPyEndAllowThreads(__tstate);
45631 if (PyErr_Occurred()) SWIG_fail;
45632 }
45633 resultobj = SWIG_Py_Void();
45634 {
45635 if (temp2) delete arg2;
45636 }
45637 return resultobj;
45638 fail:
45639 {
45640 if (temp2) delete arg2;
45641 }
45642 return NULL;
45643 }
45644
45645
45646 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45647 PyObject *resultobj = 0;
45648 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45649 wxString *arg2 = 0 ;
45650 unsigned int arg3 ;
45651 PyObject *arg4 = (PyObject *) NULL ;
45652 int result;
45653 void *argp1 = 0 ;
45654 int res1 = 0 ;
45655 bool temp2 = false ;
45656 unsigned int val3 ;
45657 int ecode3 = 0 ;
45658 PyObject * obj0 = 0 ;
45659 PyObject * obj1 = 0 ;
45660 PyObject * obj2 = 0 ;
45661 PyObject * obj3 = 0 ;
45662 char * kwnames[] = {
45663 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45664 };
45665
45666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45668 if (!SWIG_IsOK(res1)) {
45669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45670 }
45671 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45672 {
45673 arg2 = wxString_in_helper(obj1);
45674 if (arg2 == NULL) SWIG_fail;
45675 temp2 = true;
45676 }
45677 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45678 if (!SWIG_IsOK(ecode3)) {
45679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45680 }
45681 arg3 = static_cast< unsigned int >(val3);
45682 if (obj3) {
45683 arg4 = obj3;
45684 }
45685 {
45686 PyThreadState* __tstate = wxPyBeginAllowThreads();
45687 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45688 wxPyEndAllowThreads(__tstate);
45689 if (PyErr_Occurred()) SWIG_fail;
45690 }
45691 resultobj = SWIG_From_int(static_cast< int >(result));
45692 {
45693 if (temp2)
45694 delete arg2;
45695 }
45696 return resultobj;
45697 fail:
45698 {
45699 if (temp2)
45700 delete arg2;
45701 }
45702 return NULL;
45703 }
45704
45705
45706 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45707 PyObject *resultobj = 0;
45708 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45709 void *argp1 = 0 ;
45710 int res1 = 0 ;
45711 PyObject *swig_obj[1] ;
45712
45713 if (!args) SWIG_fail;
45714 swig_obj[0] = args;
45715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45716 if (!SWIG_IsOK(res1)) {
45717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45718 }
45719 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45720 {
45721 PyThreadState* __tstate = wxPyBeginAllowThreads();
45722 (arg1)->Clear();
45723 wxPyEndAllowThreads(__tstate);
45724 if (PyErr_Occurred()) SWIG_fail;
45725 }
45726 resultobj = SWIG_Py_Void();
45727 return resultobj;
45728 fail:
45729 return NULL;
45730 }
45731
45732
45733 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45734 PyObject *resultobj = 0;
45735 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45736 unsigned int arg2 ;
45737 void *argp1 = 0 ;
45738 int res1 = 0 ;
45739 unsigned int val2 ;
45740 int ecode2 = 0 ;
45741 PyObject * obj0 = 0 ;
45742 PyObject * obj1 = 0 ;
45743 char * kwnames[] = {
45744 (char *) "self",(char *) "n", NULL
45745 };
45746
45747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45749 if (!SWIG_IsOK(res1)) {
45750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45751 }
45752 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45753 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45754 if (!SWIG_IsOK(ecode2)) {
45755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45756 }
45757 arg2 = static_cast< unsigned int >(val2);
45758 {
45759 PyThreadState* __tstate = wxPyBeginAllowThreads();
45760 (arg1)->Delete(arg2);
45761 wxPyEndAllowThreads(__tstate);
45762 if (PyErr_Occurred()) SWIG_fail;
45763 }
45764 resultobj = SWIG_Py_Void();
45765 return resultobj;
45766 fail:
45767 return NULL;
45768 }
45769
45770
45771 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45772 PyObject *resultobj = 0;
45773 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45774 unsigned int arg2 ;
45775 PyObject *result = 0 ;
45776 void *argp1 = 0 ;
45777 int res1 = 0 ;
45778 unsigned int val2 ;
45779 int ecode2 = 0 ;
45780 PyObject * obj0 = 0 ;
45781 PyObject * obj1 = 0 ;
45782 char * kwnames[] = {
45783 (char *) "self",(char *) "n", NULL
45784 };
45785
45786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45788 if (!SWIG_IsOK(res1)) {
45789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45790 }
45791 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45792 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45793 if (!SWIG_IsOK(ecode2)) {
45794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45795 }
45796 arg2 = static_cast< unsigned int >(val2);
45797 {
45798 PyThreadState* __tstate = wxPyBeginAllowThreads();
45799 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45800 wxPyEndAllowThreads(__tstate);
45801 if (PyErr_Occurred()) SWIG_fail;
45802 }
45803 resultobj = result;
45804 return resultobj;
45805 fail:
45806 return NULL;
45807 }
45808
45809
45810 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45811 PyObject *resultobj = 0;
45812 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45813 unsigned int arg2 ;
45814 PyObject *arg3 = (PyObject *) 0 ;
45815 void *argp1 = 0 ;
45816 int res1 = 0 ;
45817 unsigned int val2 ;
45818 int ecode2 = 0 ;
45819 PyObject * obj0 = 0 ;
45820 PyObject * obj1 = 0 ;
45821 PyObject * obj2 = 0 ;
45822 char * kwnames[] = {
45823 (char *) "self",(char *) "n",(char *) "clientData", NULL
45824 };
45825
45826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45828 if (!SWIG_IsOK(res1)) {
45829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45830 }
45831 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45832 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45833 if (!SWIG_IsOK(ecode2)) {
45834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45835 }
45836 arg2 = static_cast< unsigned int >(val2);
45837 arg3 = obj2;
45838 {
45839 PyThreadState* __tstate = wxPyBeginAllowThreads();
45840 wxItemContainer_SetClientData(arg1,arg2,arg3);
45841 wxPyEndAllowThreads(__tstate);
45842 if (PyErr_Occurred()) SWIG_fail;
45843 }
45844 resultobj = SWIG_Py_Void();
45845 return resultobj;
45846 fail:
45847 return NULL;
45848 }
45849
45850
45851 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45852 PyObject *resultobj = 0;
45853 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45854 unsigned int result;
45855 void *argp1 = 0 ;
45856 int res1 = 0 ;
45857 PyObject *swig_obj[1] ;
45858
45859 if (!args) SWIG_fail;
45860 swig_obj[0] = args;
45861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45862 if (!SWIG_IsOK(res1)) {
45863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45864 }
45865 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45866 {
45867 PyThreadState* __tstate = wxPyBeginAllowThreads();
45868 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45869 wxPyEndAllowThreads(__tstate);
45870 if (PyErr_Occurred()) SWIG_fail;
45871 }
45872 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45873 return resultobj;
45874 fail:
45875 return NULL;
45876 }
45877
45878
45879 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45880 PyObject *resultobj = 0;
45881 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45882 bool result;
45883 void *argp1 = 0 ;
45884 int res1 = 0 ;
45885 PyObject *swig_obj[1] ;
45886
45887 if (!args) SWIG_fail;
45888 swig_obj[0] = args;
45889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45890 if (!SWIG_IsOK(res1)) {
45891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45892 }
45893 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45894 {
45895 PyThreadState* __tstate = wxPyBeginAllowThreads();
45896 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45897 wxPyEndAllowThreads(__tstate);
45898 if (PyErr_Occurred()) SWIG_fail;
45899 }
45900 {
45901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45902 }
45903 return resultobj;
45904 fail:
45905 return NULL;
45906 }
45907
45908
45909 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45910 PyObject *resultobj = 0;
45911 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45912 unsigned int arg2 ;
45913 wxString result;
45914 void *argp1 = 0 ;
45915 int res1 = 0 ;
45916 unsigned int val2 ;
45917 int ecode2 = 0 ;
45918 PyObject * obj0 = 0 ;
45919 PyObject * obj1 = 0 ;
45920 char * kwnames[] = {
45921 (char *) "self",(char *) "n", NULL
45922 };
45923
45924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45926 if (!SWIG_IsOK(res1)) {
45927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45928 }
45929 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45930 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45931 if (!SWIG_IsOK(ecode2)) {
45932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45933 }
45934 arg2 = static_cast< unsigned int >(val2);
45935 {
45936 PyThreadState* __tstate = wxPyBeginAllowThreads();
45937 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45938 wxPyEndAllowThreads(__tstate);
45939 if (PyErr_Occurred()) SWIG_fail;
45940 }
45941 {
45942 #if wxUSE_UNICODE
45943 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45944 #else
45945 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45946 #endif
45947 }
45948 return resultobj;
45949 fail:
45950 return NULL;
45951 }
45952
45953
45954 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45955 PyObject *resultobj = 0;
45956 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45957 wxArrayString result;
45958 void *argp1 = 0 ;
45959 int res1 = 0 ;
45960 PyObject *swig_obj[1] ;
45961
45962 if (!args) SWIG_fail;
45963 swig_obj[0] = args;
45964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45965 if (!SWIG_IsOK(res1)) {
45966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45967 }
45968 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45969 {
45970 PyThreadState* __tstate = wxPyBeginAllowThreads();
45971 result = ((wxItemContainer const *)arg1)->GetStrings();
45972 wxPyEndAllowThreads(__tstate);
45973 if (PyErr_Occurred()) SWIG_fail;
45974 }
45975 {
45976 resultobj = wxArrayString2PyList_helper(result);
45977 }
45978 return resultobj;
45979 fail:
45980 return NULL;
45981 }
45982
45983
45984 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45985 PyObject *resultobj = 0;
45986 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45987 unsigned int arg2 ;
45988 wxString *arg3 = 0 ;
45989 void *argp1 = 0 ;
45990 int res1 = 0 ;
45991 unsigned int val2 ;
45992 int ecode2 = 0 ;
45993 bool temp3 = false ;
45994 PyObject * obj0 = 0 ;
45995 PyObject * obj1 = 0 ;
45996 PyObject * obj2 = 0 ;
45997 char * kwnames[] = {
45998 (char *) "self",(char *) "n",(char *) "s", NULL
45999 };
46000
46001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46003 if (!SWIG_IsOK(res1)) {
46004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46005 }
46006 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46007 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
46008 if (!SWIG_IsOK(ecode2)) {
46009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
46010 }
46011 arg2 = static_cast< unsigned int >(val2);
46012 {
46013 arg3 = wxString_in_helper(obj2);
46014 if (arg3 == NULL) SWIG_fail;
46015 temp3 = true;
46016 }
46017 {
46018 PyThreadState* __tstate = wxPyBeginAllowThreads();
46019 (arg1)->SetString(arg2,(wxString const &)*arg3);
46020 wxPyEndAllowThreads(__tstate);
46021 if (PyErr_Occurred()) SWIG_fail;
46022 }
46023 resultobj = SWIG_Py_Void();
46024 {
46025 if (temp3)
46026 delete arg3;
46027 }
46028 return resultobj;
46029 fail:
46030 {
46031 if (temp3)
46032 delete arg3;
46033 }
46034 return NULL;
46035 }
46036
46037
46038 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46039 PyObject *resultobj = 0;
46040 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46041 wxString *arg2 = 0 ;
46042 int result;
46043 void *argp1 = 0 ;
46044 int res1 = 0 ;
46045 bool temp2 = false ;
46046 PyObject * obj0 = 0 ;
46047 PyObject * obj1 = 0 ;
46048 char * kwnames[] = {
46049 (char *) "self",(char *) "s", NULL
46050 };
46051
46052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
46053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46054 if (!SWIG_IsOK(res1)) {
46055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46056 }
46057 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46058 {
46059 arg2 = wxString_in_helper(obj1);
46060 if (arg2 == NULL) SWIG_fail;
46061 temp2 = true;
46062 }
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 resultobj = SWIG_From_int(static_cast< int >(result));
46070 {
46071 if (temp2)
46072 delete arg2;
46073 }
46074 return resultobj;
46075 fail:
46076 {
46077 if (temp2)
46078 delete arg2;
46079 }
46080 return NULL;
46081 }
46082
46083
46084 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46085 PyObject *resultobj = 0;
46086 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46087 int arg2 ;
46088 void *argp1 = 0 ;
46089 int res1 = 0 ;
46090 int val2 ;
46091 int ecode2 = 0 ;
46092 PyObject * obj0 = 0 ;
46093 PyObject * obj1 = 0 ;
46094 char * kwnames[] = {
46095 (char *) "self",(char *) "n", NULL
46096 };
46097
46098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46100 if (!SWIG_IsOK(res1)) {
46101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46102 }
46103 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46104 ecode2 = SWIG_AsVal_int(obj1, &val2);
46105 if (!SWIG_IsOK(ecode2)) {
46106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
46107 }
46108 arg2 = static_cast< int >(val2);
46109 {
46110 PyThreadState* __tstate = wxPyBeginAllowThreads();
46111 (arg1)->SetSelection(arg2);
46112 wxPyEndAllowThreads(__tstate);
46113 if (PyErr_Occurred()) SWIG_fail;
46114 }
46115 resultobj = SWIG_Py_Void();
46116 return resultobj;
46117 fail:
46118 return NULL;
46119 }
46120
46121
46122 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46123 PyObject *resultobj = 0;
46124 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46125 int result;
46126 void *argp1 = 0 ;
46127 int res1 = 0 ;
46128 PyObject *swig_obj[1] ;
46129
46130 if (!args) SWIG_fail;
46131 swig_obj[0] = args;
46132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46133 if (!SWIG_IsOK(res1)) {
46134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46135 }
46136 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46137 {
46138 PyThreadState* __tstate = wxPyBeginAllowThreads();
46139 result = (int)((wxItemContainer const *)arg1)->GetSelection();
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 resultobj = SWIG_From_int(static_cast< int >(result));
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46153 wxString *arg2 = 0 ;
46154 bool result;
46155 void *argp1 = 0 ;
46156 int res1 = 0 ;
46157 bool temp2 = false ;
46158 PyObject * obj0 = 0 ;
46159 PyObject * obj1 = 0 ;
46160 char * kwnames[] = {
46161 (char *) "self",(char *) "s", NULL
46162 };
46163
46164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46166 if (!SWIG_IsOK(res1)) {
46167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46168 }
46169 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46170 {
46171 arg2 = wxString_in_helper(obj1);
46172 if (arg2 == NULL) SWIG_fail;
46173 temp2 = true;
46174 }
46175 {
46176 PyThreadState* __tstate = wxPyBeginAllowThreads();
46177 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
46178 wxPyEndAllowThreads(__tstate);
46179 if (PyErr_Occurred()) SWIG_fail;
46180 }
46181 {
46182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46183 }
46184 {
46185 if (temp2)
46186 delete arg2;
46187 }
46188 return resultobj;
46189 fail:
46190 {
46191 if (temp2)
46192 delete arg2;
46193 }
46194 return NULL;
46195 }
46196
46197
46198 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46199 PyObject *resultobj = 0;
46200 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46201 wxString result;
46202 void *argp1 = 0 ;
46203 int res1 = 0 ;
46204 PyObject *swig_obj[1] ;
46205
46206 if (!args) SWIG_fail;
46207 swig_obj[0] = args;
46208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46209 if (!SWIG_IsOK(res1)) {
46210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46211 }
46212 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46213 {
46214 PyThreadState* __tstate = wxPyBeginAllowThreads();
46215 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46216 wxPyEndAllowThreads(__tstate);
46217 if (PyErr_Occurred()) SWIG_fail;
46218 }
46219 {
46220 #if wxUSE_UNICODE
46221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46222 #else
46223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46224 #endif
46225 }
46226 return resultobj;
46227 fail:
46228 return NULL;
46229 }
46230
46231
46232 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46233 PyObject *resultobj = 0;
46234 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46235 int arg2 ;
46236 void *argp1 = 0 ;
46237 int res1 = 0 ;
46238 int val2 ;
46239 int ecode2 = 0 ;
46240 PyObject * obj0 = 0 ;
46241 PyObject * obj1 = 0 ;
46242 char * kwnames[] = {
46243 (char *) "self",(char *) "n", NULL
46244 };
46245
46246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46248 if (!SWIG_IsOK(res1)) {
46249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46250 }
46251 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46252 ecode2 = SWIG_AsVal_int(obj1, &val2);
46253 if (!SWIG_IsOK(ecode2)) {
46254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46255 }
46256 arg2 = static_cast< int >(val2);
46257 {
46258 PyThreadState* __tstate = wxPyBeginAllowThreads();
46259 (arg1)->Select(arg2);
46260 wxPyEndAllowThreads(__tstate);
46261 if (PyErr_Occurred()) SWIG_fail;
46262 }
46263 resultobj = SWIG_Py_Void();
46264 return resultobj;
46265 fail:
46266 return NULL;
46267 }
46268
46269
46270 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46271 PyObject *obj;
46272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46273 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46274 return SWIG_Py_Void();
46275 }
46276
46277 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46278 PyObject *obj;
46279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46280 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46281 return SWIG_Py_Void();
46282 }
46283
46284 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46285 PyObject *resultobj = 0;
46286 wxSizerItem *result = 0 ;
46287
46288 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46289 {
46290 PyThreadState* __tstate = wxPyBeginAllowThreads();
46291 result = (wxSizerItem *)new wxSizerItem();
46292 wxPyEndAllowThreads(__tstate);
46293 if (PyErr_Occurred()) SWIG_fail;
46294 }
46295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46296 return resultobj;
46297 fail:
46298 return NULL;
46299 }
46300
46301
46302 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46303 PyObject *resultobj = 0;
46304 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46305 void *argp1 = 0 ;
46306 int res1 = 0 ;
46307 PyObject *swig_obj[1] ;
46308
46309 if (!args) SWIG_fail;
46310 swig_obj[0] = args;
46311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46312 if (!SWIG_IsOK(res1)) {
46313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46314 }
46315 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46316 {
46317 PyThreadState* __tstate = wxPyBeginAllowThreads();
46318 delete arg1;
46319
46320 wxPyEndAllowThreads(__tstate);
46321 if (PyErr_Occurred()) SWIG_fail;
46322 }
46323 resultobj = SWIG_Py_Void();
46324 return resultobj;
46325 fail:
46326 return NULL;
46327 }
46328
46329
46330 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46331 PyObject *resultobj = 0;
46332 wxWindow *arg1 = (wxWindow *) 0 ;
46333 int arg2 ;
46334 int arg3 ;
46335 int arg4 ;
46336 PyObject *arg5 = (PyObject *) NULL ;
46337 wxSizerItem *result = 0 ;
46338 void *argp1 = 0 ;
46339 int res1 = 0 ;
46340 int val2 ;
46341 int ecode2 = 0 ;
46342 int val3 ;
46343 int ecode3 = 0 ;
46344 int val4 ;
46345 int ecode4 = 0 ;
46346 PyObject * obj0 = 0 ;
46347 PyObject * obj1 = 0 ;
46348 PyObject * obj2 = 0 ;
46349 PyObject * obj3 = 0 ;
46350 PyObject * obj4 = 0 ;
46351 char * kwnames[] = {
46352 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46353 };
46354
46355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46357 if (!SWIG_IsOK(res1)) {
46358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46359 }
46360 arg1 = reinterpret_cast< wxWindow * >(argp1);
46361 ecode2 = SWIG_AsVal_int(obj1, &val2);
46362 if (!SWIG_IsOK(ecode2)) {
46363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46364 }
46365 arg2 = static_cast< int >(val2);
46366 ecode3 = SWIG_AsVal_int(obj2, &val3);
46367 if (!SWIG_IsOK(ecode3)) {
46368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46369 }
46370 arg3 = static_cast< int >(val3);
46371 ecode4 = SWIG_AsVal_int(obj3, &val4);
46372 if (!SWIG_IsOK(ecode4)) {
46373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46374 }
46375 arg4 = static_cast< int >(val4);
46376 if (obj4) {
46377 arg5 = obj4;
46378 }
46379 {
46380 PyThreadState* __tstate = wxPyBeginAllowThreads();
46381 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46382 wxPyEndAllowThreads(__tstate);
46383 if (PyErr_Occurred()) SWIG_fail;
46384 }
46385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46386 return resultobj;
46387 fail:
46388 return NULL;
46389 }
46390
46391
46392 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46393 PyObject *resultobj = 0;
46394 int arg1 ;
46395 int arg2 ;
46396 int arg3 ;
46397 int arg4 ;
46398 int arg5 ;
46399 PyObject *arg6 = (PyObject *) NULL ;
46400 wxSizerItem *result = 0 ;
46401 int val1 ;
46402 int ecode1 = 0 ;
46403 int val2 ;
46404 int ecode2 = 0 ;
46405 int val3 ;
46406 int ecode3 = 0 ;
46407 int val4 ;
46408 int ecode4 = 0 ;
46409 int val5 ;
46410 int ecode5 = 0 ;
46411 PyObject * obj0 = 0 ;
46412 PyObject * obj1 = 0 ;
46413 PyObject * obj2 = 0 ;
46414 PyObject * obj3 = 0 ;
46415 PyObject * obj4 = 0 ;
46416 PyObject * obj5 = 0 ;
46417 char * kwnames[] = {
46418 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46419 };
46420
46421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46422 ecode1 = SWIG_AsVal_int(obj0, &val1);
46423 if (!SWIG_IsOK(ecode1)) {
46424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46425 }
46426 arg1 = static_cast< int >(val1);
46427 ecode2 = SWIG_AsVal_int(obj1, &val2);
46428 if (!SWIG_IsOK(ecode2)) {
46429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46430 }
46431 arg2 = static_cast< int >(val2);
46432 ecode3 = SWIG_AsVal_int(obj2, &val3);
46433 if (!SWIG_IsOK(ecode3)) {
46434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46435 }
46436 arg3 = static_cast< int >(val3);
46437 ecode4 = SWIG_AsVal_int(obj3, &val4);
46438 if (!SWIG_IsOK(ecode4)) {
46439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46440 }
46441 arg4 = static_cast< int >(val4);
46442 ecode5 = SWIG_AsVal_int(obj4, &val5);
46443 if (!SWIG_IsOK(ecode5)) {
46444 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46445 }
46446 arg5 = static_cast< int >(val5);
46447 if (obj5) {
46448 arg6 = obj5;
46449 }
46450 {
46451 PyThreadState* __tstate = wxPyBeginAllowThreads();
46452 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46453 wxPyEndAllowThreads(__tstate);
46454 if (PyErr_Occurred()) SWIG_fail;
46455 }
46456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46457 return resultobj;
46458 fail:
46459 return NULL;
46460 }
46461
46462
46463 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46464 PyObject *resultobj = 0;
46465 wxSizer *arg1 = (wxSizer *) 0 ;
46466 int arg2 ;
46467 int arg3 ;
46468 int arg4 ;
46469 PyObject *arg5 = (PyObject *) NULL ;
46470 wxSizerItem *result = 0 ;
46471 int res1 = 0 ;
46472 int val2 ;
46473 int ecode2 = 0 ;
46474 int val3 ;
46475 int ecode3 = 0 ;
46476 int val4 ;
46477 int ecode4 = 0 ;
46478 PyObject * obj0 = 0 ;
46479 PyObject * obj1 = 0 ;
46480 PyObject * obj2 = 0 ;
46481 PyObject * obj3 = 0 ;
46482 PyObject * obj4 = 0 ;
46483 char * kwnames[] = {
46484 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46485 };
46486
46487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46488 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46489 if (!SWIG_IsOK(res1)) {
46490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46491 }
46492 ecode2 = SWIG_AsVal_int(obj1, &val2);
46493 if (!SWIG_IsOK(ecode2)) {
46494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46495 }
46496 arg2 = static_cast< int >(val2);
46497 ecode3 = SWIG_AsVal_int(obj2, &val3);
46498 if (!SWIG_IsOK(ecode3)) {
46499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46500 }
46501 arg3 = static_cast< int >(val3);
46502 ecode4 = SWIG_AsVal_int(obj3, &val4);
46503 if (!SWIG_IsOK(ecode4)) {
46504 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46505 }
46506 arg4 = static_cast< int >(val4);
46507 if (obj4) {
46508 arg5 = obj4;
46509 }
46510 {
46511 PyThreadState* __tstate = wxPyBeginAllowThreads();
46512 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46513 wxPyEndAllowThreads(__tstate);
46514 if (PyErr_Occurred()) SWIG_fail;
46515 }
46516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46517 return resultobj;
46518 fail:
46519 return NULL;
46520 }
46521
46522
46523 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46524 PyObject *resultobj = 0;
46525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46526 void *argp1 = 0 ;
46527 int res1 = 0 ;
46528 PyObject *swig_obj[1] ;
46529
46530 if (!args) SWIG_fail;
46531 swig_obj[0] = args;
46532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46533 if (!SWIG_IsOK(res1)) {
46534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46535 }
46536 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46537 {
46538 PyThreadState* __tstate = wxPyBeginAllowThreads();
46539 (arg1)->DeleteWindows();
46540 wxPyEndAllowThreads(__tstate);
46541 if (PyErr_Occurred()) SWIG_fail;
46542 }
46543 resultobj = SWIG_Py_Void();
46544 return resultobj;
46545 fail:
46546 return NULL;
46547 }
46548
46549
46550 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46551 PyObject *resultobj = 0;
46552 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46553 void *argp1 = 0 ;
46554 int res1 = 0 ;
46555 PyObject *swig_obj[1] ;
46556
46557 if (!args) SWIG_fail;
46558 swig_obj[0] = args;
46559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46560 if (!SWIG_IsOK(res1)) {
46561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46562 }
46563 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46564 {
46565 PyThreadState* __tstate = wxPyBeginAllowThreads();
46566 (arg1)->DetachSizer();
46567 wxPyEndAllowThreads(__tstate);
46568 if (PyErr_Occurred()) SWIG_fail;
46569 }
46570 resultobj = SWIG_Py_Void();
46571 return resultobj;
46572 fail:
46573 return NULL;
46574 }
46575
46576
46577 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46578 PyObject *resultobj = 0;
46579 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46580 wxSize result;
46581 void *argp1 = 0 ;
46582 int res1 = 0 ;
46583 PyObject *swig_obj[1] ;
46584
46585 if (!args) SWIG_fail;
46586 swig_obj[0] = args;
46587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46588 if (!SWIG_IsOK(res1)) {
46589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46590 }
46591 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46592 {
46593 PyThreadState* __tstate = wxPyBeginAllowThreads();
46594 result = (arg1)->GetSize();
46595 wxPyEndAllowThreads(__tstate);
46596 if (PyErr_Occurred()) SWIG_fail;
46597 }
46598 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46599 return resultobj;
46600 fail:
46601 return NULL;
46602 }
46603
46604
46605 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46606 PyObject *resultobj = 0;
46607 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46608 wxSize result;
46609 void *argp1 = 0 ;
46610 int res1 = 0 ;
46611 PyObject *swig_obj[1] ;
46612
46613 if (!args) SWIG_fail;
46614 swig_obj[0] = args;
46615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46616 if (!SWIG_IsOK(res1)) {
46617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46618 }
46619 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46620 {
46621 PyThreadState* __tstate = wxPyBeginAllowThreads();
46622 result = (arg1)->CalcMin();
46623 wxPyEndAllowThreads(__tstate);
46624 if (PyErr_Occurred()) SWIG_fail;
46625 }
46626 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46627 return resultobj;
46628 fail:
46629 return NULL;
46630 }
46631
46632
46633 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46634 PyObject *resultobj = 0;
46635 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46636 wxPoint *arg2 = 0 ;
46637 wxSize *arg3 = 0 ;
46638 void *argp1 = 0 ;
46639 int res1 = 0 ;
46640 wxPoint temp2 ;
46641 wxSize temp3 ;
46642 PyObject * obj0 = 0 ;
46643 PyObject * obj1 = 0 ;
46644 PyObject * obj2 = 0 ;
46645 char * kwnames[] = {
46646 (char *) "self",(char *) "pos",(char *) "size", NULL
46647 };
46648
46649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46651 if (!SWIG_IsOK(res1)) {
46652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46653 }
46654 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46655 {
46656 arg2 = &temp2;
46657 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46658 }
46659 {
46660 arg3 = &temp3;
46661 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46662 }
46663 {
46664 PyThreadState* __tstate = wxPyBeginAllowThreads();
46665 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46666 wxPyEndAllowThreads(__tstate);
46667 if (PyErr_Occurred()) SWIG_fail;
46668 }
46669 resultobj = SWIG_Py_Void();
46670 return resultobj;
46671 fail:
46672 return NULL;
46673 }
46674
46675
46676 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46677 PyObject *resultobj = 0;
46678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46679 wxSize result;
46680 void *argp1 = 0 ;
46681 int res1 = 0 ;
46682 PyObject *swig_obj[1] ;
46683
46684 if (!args) SWIG_fail;
46685 swig_obj[0] = args;
46686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46687 if (!SWIG_IsOK(res1)) {
46688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46689 }
46690 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46691 {
46692 PyThreadState* __tstate = wxPyBeginAllowThreads();
46693 result = (arg1)->GetMinSize();
46694 wxPyEndAllowThreads(__tstate);
46695 if (PyErr_Occurred()) SWIG_fail;
46696 }
46697 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46698 return resultobj;
46699 fail:
46700 return NULL;
46701 }
46702
46703
46704 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46705 PyObject *resultobj = 0;
46706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46707 wxSize result;
46708 void *argp1 = 0 ;
46709 int res1 = 0 ;
46710 PyObject *swig_obj[1] ;
46711
46712 if (!args) SWIG_fail;
46713 swig_obj[0] = args;
46714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46715 if (!SWIG_IsOK(res1)) {
46716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46717 }
46718 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46719 {
46720 PyThreadState* __tstate = wxPyBeginAllowThreads();
46721 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46722 wxPyEndAllowThreads(__tstate);
46723 if (PyErr_Occurred()) SWIG_fail;
46724 }
46725 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46726 return resultobj;
46727 fail:
46728 return NULL;
46729 }
46730
46731
46732 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46733 PyObject *resultobj = 0;
46734 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46735 int arg2 ;
46736 int arg3 ;
46737 void *argp1 = 0 ;
46738 int res1 = 0 ;
46739 int val2 ;
46740 int ecode2 = 0 ;
46741 int val3 ;
46742 int ecode3 = 0 ;
46743 PyObject * obj0 = 0 ;
46744 PyObject * obj1 = 0 ;
46745 PyObject * obj2 = 0 ;
46746 char * kwnames[] = {
46747 (char *) "self",(char *) "x",(char *) "y", NULL
46748 };
46749
46750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46752 if (!SWIG_IsOK(res1)) {
46753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46754 }
46755 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46756 ecode2 = SWIG_AsVal_int(obj1, &val2);
46757 if (!SWIG_IsOK(ecode2)) {
46758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46759 }
46760 arg2 = static_cast< int >(val2);
46761 ecode3 = SWIG_AsVal_int(obj2, &val3);
46762 if (!SWIG_IsOK(ecode3)) {
46763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46764 }
46765 arg3 = static_cast< int >(val3);
46766 {
46767 PyThreadState* __tstate = wxPyBeginAllowThreads();
46768 (arg1)->SetInitSize(arg2,arg3);
46769 wxPyEndAllowThreads(__tstate);
46770 if (PyErr_Occurred()) SWIG_fail;
46771 }
46772 resultobj = SWIG_Py_Void();
46773 return resultobj;
46774 fail:
46775 return NULL;
46776 }
46777
46778
46779 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46780 PyObject *resultobj = 0;
46781 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46782 int arg2 ;
46783 int arg3 ;
46784 void *argp1 = 0 ;
46785 int res1 = 0 ;
46786 int val2 ;
46787 int ecode2 = 0 ;
46788 int val3 ;
46789 int ecode3 = 0 ;
46790 PyObject * obj0 = 0 ;
46791 PyObject * obj1 = 0 ;
46792 PyObject * obj2 = 0 ;
46793 char * kwnames[] = {
46794 (char *) "self",(char *) "width",(char *) "height", NULL
46795 };
46796
46797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46799 if (!SWIG_IsOK(res1)) {
46800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46801 }
46802 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46803 ecode2 = SWIG_AsVal_int(obj1, &val2);
46804 if (!SWIG_IsOK(ecode2)) {
46805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46806 }
46807 arg2 = static_cast< int >(val2);
46808 ecode3 = SWIG_AsVal_int(obj2, &val3);
46809 if (!SWIG_IsOK(ecode3)) {
46810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46811 }
46812 arg3 = static_cast< int >(val3);
46813 {
46814 PyThreadState* __tstate = wxPyBeginAllowThreads();
46815 (arg1)->SetRatio(arg2,arg3);
46816 wxPyEndAllowThreads(__tstate);
46817 if (PyErr_Occurred()) SWIG_fail;
46818 }
46819 resultobj = SWIG_Py_Void();
46820 return resultobj;
46821 fail:
46822 return NULL;
46823 }
46824
46825
46826 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46827 PyObject *resultobj = 0;
46828 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46829 wxSize *arg2 = 0 ;
46830 void *argp1 = 0 ;
46831 int res1 = 0 ;
46832 wxSize temp2 ;
46833 PyObject * obj0 = 0 ;
46834 PyObject * obj1 = 0 ;
46835 char * kwnames[] = {
46836 (char *) "self",(char *) "size", NULL
46837 };
46838
46839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46841 if (!SWIG_IsOK(res1)) {
46842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46843 }
46844 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46845 {
46846 arg2 = &temp2;
46847 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46848 }
46849 {
46850 PyThreadState* __tstate = wxPyBeginAllowThreads();
46851 (arg1)->SetRatio((wxSize const &)*arg2);
46852 wxPyEndAllowThreads(__tstate);
46853 if (PyErr_Occurred()) SWIG_fail;
46854 }
46855 resultobj = SWIG_Py_Void();
46856 return resultobj;
46857 fail:
46858 return NULL;
46859 }
46860
46861
46862 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46863 PyObject *resultobj = 0;
46864 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46865 float arg2 ;
46866 void *argp1 = 0 ;
46867 int res1 = 0 ;
46868 float val2 ;
46869 int ecode2 = 0 ;
46870 PyObject * obj0 = 0 ;
46871 PyObject * obj1 = 0 ;
46872 char * kwnames[] = {
46873 (char *) "self",(char *) "ratio", NULL
46874 };
46875
46876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46878 if (!SWIG_IsOK(res1)) {
46879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46880 }
46881 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46882 ecode2 = SWIG_AsVal_float(obj1, &val2);
46883 if (!SWIG_IsOK(ecode2)) {
46884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46885 }
46886 arg2 = static_cast< float >(val2);
46887 {
46888 PyThreadState* __tstate = wxPyBeginAllowThreads();
46889 (arg1)->SetRatio(arg2);
46890 wxPyEndAllowThreads(__tstate);
46891 if (PyErr_Occurred()) SWIG_fail;
46892 }
46893 resultobj = SWIG_Py_Void();
46894 return resultobj;
46895 fail:
46896 return NULL;
46897 }
46898
46899
46900 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46901 PyObject *resultobj = 0;
46902 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46903 float result;
46904 void *argp1 = 0 ;
46905 int res1 = 0 ;
46906 PyObject *swig_obj[1] ;
46907
46908 if (!args) SWIG_fail;
46909 swig_obj[0] = args;
46910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46911 if (!SWIG_IsOK(res1)) {
46912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46913 }
46914 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46915 {
46916 PyThreadState* __tstate = wxPyBeginAllowThreads();
46917 result = (float)(arg1)->GetRatio();
46918 wxPyEndAllowThreads(__tstate);
46919 if (PyErr_Occurred()) SWIG_fail;
46920 }
46921 resultobj = SWIG_From_float(static_cast< float >(result));
46922 return resultobj;
46923 fail:
46924 return NULL;
46925 }
46926
46927
46928 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46929 PyObject *resultobj = 0;
46930 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46931 wxRect result;
46932 void *argp1 = 0 ;
46933 int res1 = 0 ;
46934 PyObject *swig_obj[1] ;
46935
46936 if (!args) SWIG_fail;
46937 swig_obj[0] = args;
46938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46939 if (!SWIG_IsOK(res1)) {
46940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46941 }
46942 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46943 {
46944 PyThreadState* __tstate = wxPyBeginAllowThreads();
46945 result = (arg1)->GetRect();
46946 wxPyEndAllowThreads(__tstate);
46947 if (PyErr_Occurred()) SWIG_fail;
46948 }
46949 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46950 return resultobj;
46951 fail:
46952 return NULL;
46953 }
46954
46955
46956 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46957 PyObject *resultobj = 0;
46958 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46959 bool result;
46960 void *argp1 = 0 ;
46961 int res1 = 0 ;
46962 PyObject *swig_obj[1] ;
46963
46964 if (!args) SWIG_fail;
46965 swig_obj[0] = args;
46966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46967 if (!SWIG_IsOK(res1)) {
46968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46969 }
46970 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46971 {
46972 PyThreadState* __tstate = wxPyBeginAllowThreads();
46973 result = (bool)(arg1)->IsWindow();
46974 wxPyEndAllowThreads(__tstate);
46975 if (PyErr_Occurred()) SWIG_fail;
46976 }
46977 {
46978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46979 }
46980 return resultobj;
46981 fail:
46982 return NULL;
46983 }
46984
46985
46986 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46987 PyObject *resultobj = 0;
46988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46989 bool result;
46990 void *argp1 = 0 ;
46991 int res1 = 0 ;
46992 PyObject *swig_obj[1] ;
46993
46994 if (!args) SWIG_fail;
46995 swig_obj[0] = args;
46996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46997 if (!SWIG_IsOK(res1)) {
46998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46999 }
47000 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47001 {
47002 PyThreadState* __tstate = wxPyBeginAllowThreads();
47003 result = (bool)(arg1)->IsSizer();
47004 wxPyEndAllowThreads(__tstate);
47005 if (PyErr_Occurred()) SWIG_fail;
47006 }
47007 {
47008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47009 }
47010 return resultobj;
47011 fail:
47012 return NULL;
47013 }
47014
47015
47016 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47017 PyObject *resultobj = 0;
47018 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47019 bool result;
47020 void *argp1 = 0 ;
47021 int res1 = 0 ;
47022 PyObject *swig_obj[1] ;
47023
47024 if (!args) SWIG_fail;
47025 swig_obj[0] = args;
47026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47027 if (!SWIG_IsOK(res1)) {
47028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47029 }
47030 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47031 {
47032 PyThreadState* __tstate = wxPyBeginAllowThreads();
47033 result = (bool)(arg1)->IsSpacer();
47034 wxPyEndAllowThreads(__tstate);
47035 if (PyErr_Occurred()) SWIG_fail;
47036 }
47037 {
47038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47039 }
47040 return resultobj;
47041 fail:
47042 return NULL;
47043 }
47044
47045
47046 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47047 PyObject *resultobj = 0;
47048 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47049 int arg2 ;
47050 void *argp1 = 0 ;
47051 int res1 = 0 ;
47052 int val2 ;
47053 int ecode2 = 0 ;
47054 PyObject * obj0 = 0 ;
47055 PyObject * obj1 = 0 ;
47056 char * kwnames[] = {
47057 (char *) "self",(char *) "proportion", NULL
47058 };
47059
47060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
47061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47062 if (!SWIG_IsOK(res1)) {
47063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47064 }
47065 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47066 ecode2 = SWIG_AsVal_int(obj1, &val2);
47067 if (!SWIG_IsOK(ecode2)) {
47068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
47069 }
47070 arg2 = static_cast< int >(val2);
47071 {
47072 PyThreadState* __tstate = wxPyBeginAllowThreads();
47073 (arg1)->SetProportion(arg2);
47074 wxPyEndAllowThreads(__tstate);
47075 if (PyErr_Occurred()) SWIG_fail;
47076 }
47077 resultobj = SWIG_Py_Void();
47078 return resultobj;
47079 fail:
47080 return NULL;
47081 }
47082
47083
47084 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47085 PyObject *resultobj = 0;
47086 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47087 int result;
47088 void *argp1 = 0 ;
47089 int res1 = 0 ;
47090 PyObject *swig_obj[1] ;
47091
47092 if (!args) SWIG_fail;
47093 swig_obj[0] = args;
47094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47095 if (!SWIG_IsOK(res1)) {
47096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47097 }
47098 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47099 {
47100 PyThreadState* __tstate = wxPyBeginAllowThreads();
47101 result = (int)(arg1)->GetProportion();
47102 wxPyEndAllowThreads(__tstate);
47103 if (PyErr_Occurred()) SWIG_fail;
47104 }
47105 resultobj = SWIG_From_int(static_cast< int >(result));
47106 return resultobj;
47107 fail:
47108 return NULL;
47109 }
47110
47111
47112 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47113 PyObject *resultobj = 0;
47114 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47115 int arg2 ;
47116 void *argp1 = 0 ;
47117 int res1 = 0 ;
47118 int val2 ;
47119 int ecode2 = 0 ;
47120 PyObject * obj0 = 0 ;
47121 PyObject * obj1 = 0 ;
47122 char * kwnames[] = {
47123 (char *) "self",(char *) "flag", NULL
47124 };
47125
47126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
47127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47128 if (!SWIG_IsOK(res1)) {
47129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47130 }
47131 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47132 ecode2 = SWIG_AsVal_int(obj1, &val2);
47133 if (!SWIG_IsOK(ecode2)) {
47134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
47135 }
47136 arg2 = static_cast< int >(val2);
47137 {
47138 PyThreadState* __tstate = wxPyBeginAllowThreads();
47139 (arg1)->SetFlag(arg2);
47140 wxPyEndAllowThreads(__tstate);
47141 if (PyErr_Occurred()) SWIG_fail;
47142 }
47143 resultobj = SWIG_Py_Void();
47144 return resultobj;
47145 fail:
47146 return NULL;
47147 }
47148
47149
47150 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47151 PyObject *resultobj = 0;
47152 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47153 int result;
47154 void *argp1 = 0 ;
47155 int res1 = 0 ;
47156 PyObject *swig_obj[1] ;
47157
47158 if (!args) SWIG_fail;
47159 swig_obj[0] = args;
47160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47161 if (!SWIG_IsOK(res1)) {
47162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47163 }
47164 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47165 {
47166 PyThreadState* __tstate = wxPyBeginAllowThreads();
47167 result = (int)(arg1)->GetFlag();
47168 wxPyEndAllowThreads(__tstate);
47169 if (PyErr_Occurred()) SWIG_fail;
47170 }
47171 resultobj = SWIG_From_int(static_cast< int >(result));
47172 return resultobj;
47173 fail:
47174 return NULL;
47175 }
47176
47177
47178 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47179 PyObject *resultobj = 0;
47180 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47181 int arg2 ;
47182 void *argp1 = 0 ;
47183 int res1 = 0 ;
47184 int val2 ;
47185 int ecode2 = 0 ;
47186 PyObject * obj0 = 0 ;
47187 PyObject * obj1 = 0 ;
47188 char * kwnames[] = {
47189 (char *) "self",(char *) "border", NULL
47190 };
47191
47192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47194 if (!SWIG_IsOK(res1)) {
47195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47196 }
47197 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47198 ecode2 = SWIG_AsVal_int(obj1, &val2);
47199 if (!SWIG_IsOK(ecode2)) {
47200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47201 }
47202 arg2 = static_cast< int >(val2);
47203 {
47204 PyThreadState* __tstate = wxPyBeginAllowThreads();
47205 (arg1)->SetBorder(arg2);
47206 wxPyEndAllowThreads(__tstate);
47207 if (PyErr_Occurred()) SWIG_fail;
47208 }
47209 resultobj = SWIG_Py_Void();
47210 return resultobj;
47211 fail:
47212 return NULL;
47213 }
47214
47215
47216 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47217 PyObject *resultobj = 0;
47218 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47219 int result;
47220 void *argp1 = 0 ;
47221 int res1 = 0 ;
47222 PyObject *swig_obj[1] ;
47223
47224 if (!args) SWIG_fail;
47225 swig_obj[0] = args;
47226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47227 if (!SWIG_IsOK(res1)) {
47228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47229 }
47230 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47231 {
47232 PyThreadState* __tstate = wxPyBeginAllowThreads();
47233 result = (int)(arg1)->GetBorder();
47234 wxPyEndAllowThreads(__tstate);
47235 if (PyErr_Occurred()) SWIG_fail;
47236 }
47237 resultobj = SWIG_From_int(static_cast< int >(result));
47238 return resultobj;
47239 fail:
47240 return NULL;
47241 }
47242
47243
47244 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47245 PyObject *resultobj = 0;
47246 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47247 wxWindow *result = 0 ;
47248 void *argp1 = 0 ;
47249 int res1 = 0 ;
47250 PyObject *swig_obj[1] ;
47251
47252 if (!args) SWIG_fail;
47253 swig_obj[0] = args;
47254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47255 if (!SWIG_IsOK(res1)) {
47256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47257 }
47258 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47259 {
47260 PyThreadState* __tstate = wxPyBeginAllowThreads();
47261 result = (wxWindow *)(arg1)->GetWindow();
47262 wxPyEndAllowThreads(__tstate);
47263 if (PyErr_Occurred()) SWIG_fail;
47264 }
47265 {
47266 resultobj = wxPyMake_wxObject(result, 0);
47267 }
47268 return resultobj;
47269 fail:
47270 return NULL;
47271 }
47272
47273
47274 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47275 PyObject *resultobj = 0;
47276 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47277 wxWindow *arg2 = (wxWindow *) 0 ;
47278 void *argp1 = 0 ;
47279 int res1 = 0 ;
47280 void *argp2 = 0 ;
47281 int res2 = 0 ;
47282 PyObject * obj0 = 0 ;
47283 PyObject * obj1 = 0 ;
47284 char * kwnames[] = {
47285 (char *) "self",(char *) "window", NULL
47286 };
47287
47288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47290 if (!SWIG_IsOK(res1)) {
47291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47292 }
47293 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47295 if (!SWIG_IsOK(res2)) {
47296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47297 }
47298 arg2 = reinterpret_cast< wxWindow * >(argp2);
47299 {
47300 PyThreadState* __tstate = wxPyBeginAllowThreads();
47301 (arg1)->SetWindow(arg2);
47302 wxPyEndAllowThreads(__tstate);
47303 if (PyErr_Occurred()) SWIG_fail;
47304 }
47305 resultobj = SWIG_Py_Void();
47306 return resultobj;
47307 fail:
47308 return NULL;
47309 }
47310
47311
47312 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47313 PyObject *resultobj = 0;
47314 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47315 wxSizer *result = 0 ;
47316 void *argp1 = 0 ;
47317 int res1 = 0 ;
47318 PyObject *swig_obj[1] ;
47319
47320 if (!args) SWIG_fail;
47321 swig_obj[0] = args;
47322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47323 if (!SWIG_IsOK(res1)) {
47324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47325 }
47326 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47327 {
47328 PyThreadState* __tstate = wxPyBeginAllowThreads();
47329 result = (wxSizer *)(arg1)->GetSizer();
47330 wxPyEndAllowThreads(__tstate);
47331 if (PyErr_Occurred()) SWIG_fail;
47332 }
47333 {
47334 resultobj = wxPyMake_wxObject(result, (bool)0);
47335 }
47336 return resultobj;
47337 fail:
47338 return NULL;
47339 }
47340
47341
47342 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47343 PyObject *resultobj = 0;
47344 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47345 wxSizer *arg2 = (wxSizer *) 0 ;
47346 void *argp1 = 0 ;
47347 int res1 = 0 ;
47348 int res2 = 0 ;
47349 PyObject * obj0 = 0 ;
47350 PyObject * obj1 = 0 ;
47351 char * kwnames[] = {
47352 (char *) "self",(char *) "sizer", NULL
47353 };
47354
47355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47357 if (!SWIG_IsOK(res1)) {
47358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47359 }
47360 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47361 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47362 if (!SWIG_IsOK(res2)) {
47363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47364 }
47365 {
47366 PyThreadState* __tstate = wxPyBeginAllowThreads();
47367 (arg1)->SetSizer(arg2);
47368 wxPyEndAllowThreads(__tstate);
47369 if (PyErr_Occurred()) SWIG_fail;
47370 }
47371 resultobj = SWIG_Py_Void();
47372 return resultobj;
47373 fail:
47374 return NULL;
47375 }
47376
47377
47378 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47379 PyObject *resultobj = 0;
47380 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47381 wxSize result;
47382 void *argp1 = 0 ;
47383 int res1 = 0 ;
47384 PyObject *swig_obj[1] ;
47385
47386 if (!args) SWIG_fail;
47387 swig_obj[0] = args;
47388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47389 if (!SWIG_IsOK(res1)) {
47390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47391 }
47392 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47393 {
47394 PyThreadState* __tstate = wxPyBeginAllowThreads();
47395 result = (arg1)->GetSpacer();
47396 wxPyEndAllowThreads(__tstate);
47397 if (PyErr_Occurred()) SWIG_fail;
47398 }
47399 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47400 return resultobj;
47401 fail:
47402 return NULL;
47403 }
47404
47405
47406 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47407 PyObject *resultobj = 0;
47408 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47409 wxSize *arg2 = 0 ;
47410 void *argp1 = 0 ;
47411 int res1 = 0 ;
47412 wxSize temp2 ;
47413 PyObject * obj0 = 0 ;
47414 PyObject * obj1 = 0 ;
47415 char * kwnames[] = {
47416 (char *) "self",(char *) "size", NULL
47417 };
47418
47419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47421 if (!SWIG_IsOK(res1)) {
47422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47423 }
47424 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47425 {
47426 arg2 = &temp2;
47427 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47428 }
47429 {
47430 PyThreadState* __tstate = wxPyBeginAllowThreads();
47431 (arg1)->SetSpacer((wxSize const &)*arg2);
47432 wxPyEndAllowThreads(__tstate);
47433 if (PyErr_Occurred()) SWIG_fail;
47434 }
47435 resultobj = SWIG_Py_Void();
47436 return resultobj;
47437 fail:
47438 return NULL;
47439 }
47440
47441
47442 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47443 PyObject *resultobj = 0;
47444 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47445 bool arg2 ;
47446 void *argp1 = 0 ;
47447 int res1 = 0 ;
47448 bool val2 ;
47449 int ecode2 = 0 ;
47450 PyObject * obj0 = 0 ;
47451 PyObject * obj1 = 0 ;
47452 char * kwnames[] = {
47453 (char *) "self",(char *) "show", NULL
47454 };
47455
47456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47458 if (!SWIG_IsOK(res1)) {
47459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47460 }
47461 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47462 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47463 if (!SWIG_IsOK(ecode2)) {
47464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47465 }
47466 arg2 = static_cast< bool >(val2);
47467 {
47468 PyThreadState* __tstate = wxPyBeginAllowThreads();
47469 (arg1)->Show(arg2);
47470 wxPyEndAllowThreads(__tstate);
47471 if (PyErr_Occurred()) SWIG_fail;
47472 }
47473 resultobj = SWIG_Py_Void();
47474 return resultobj;
47475 fail:
47476 return NULL;
47477 }
47478
47479
47480 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47481 PyObject *resultobj = 0;
47482 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47483 bool result;
47484 void *argp1 = 0 ;
47485 int res1 = 0 ;
47486 PyObject *swig_obj[1] ;
47487
47488 if (!args) SWIG_fail;
47489 swig_obj[0] = args;
47490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47491 if (!SWIG_IsOK(res1)) {
47492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47493 }
47494 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47495 {
47496 PyThreadState* __tstate = wxPyBeginAllowThreads();
47497 result = (bool)(arg1)->IsShown();
47498 wxPyEndAllowThreads(__tstate);
47499 if (PyErr_Occurred()) SWIG_fail;
47500 }
47501 {
47502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47503 }
47504 return resultobj;
47505 fail:
47506 return NULL;
47507 }
47508
47509
47510 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47511 PyObject *resultobj = 0;
47512 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47513 wxPoint result;
47514 void *argp1 = 0 ;
47515 int res1 = 0 ;
47516 PyObject *swig_obj[1] ;
47517
47518 if (!args) SWIG_fail;
47519 swig_obj[0] = args;
47520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47521 if (!SWIG_IsOK(res1)) {
47522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47523 }
47524 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47525 {
47526 PyThreadState* __tstate = wxPyBeginAllowThreads();
47527 result = (arg1)->GetPosition();
47528 wxPyEndAllowThreads(__tstate);
47529 if (PyErr_Occurred()) SWIG_fail;
47530 }
47531 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47532 return resultobj;
47533 fail:
47534 return NULL;
47535 }
47536
47537
47538 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47539 PyObject *resultobj = 0;
47540 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47541 PyObject *result = 0 ;
47542 void *argp1 = 0 ;
47543 int res1 = 0 ;
47544 PyObject *swig_obj[1] ;
47545
47546 if (!args) SWIG_fail;
47547 swig_obj[0] = args;
47548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47549 if (!SWIG_IsOK(res1)) {
47550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47551 }
47552 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47553 {
47554 PyThreadState* __tstate = wxPyBeginAllowThreads();
47555 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47556 wxPyEndAllowThreads(__tstate);
47557 if (PyErr_Occurred()) SWIG_fail;
47558 }
47559 resultobj = result;
47560 return resultobj;
47561 fail:
47562 return NULL;
47563 }
47564
47565
47566 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47567 PyObject *resultobj = 0;
47568 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47569 PyObject *arg2 = (PyObject *) 0 ;
47570 void *argp1 = 0 ;
47571 int res1 = 0 ;
47572 PyObject * obj0 = 0 ;
47573 PyObject * obj1 = 0 ;
47574 char * kwnames[] = {
47575 (char *) "self",(char *) "userData", NULL
47576 };
47577
47578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47580 if (!SWIG_IsOK(res1)) {
47581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47582 }
47583 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47584 arg2 = obj1;
47585 {
47586 PyThreadState* __tstate = wxPyBeginAllowThreads();
47587 wxSizerItem_SetUserData(arg1,arg2);
47588 wxPyEndAllowThreads(__tstate);
47589 if (PyErr_Occurred()) SWIG_fail;
47590 }
47591 resultobj = SWIG_Py_Void();
47592 return resultobj;
47593 fail:
47594 return NULL;
47595 }
47596
47597
47598 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47599 PyObject *obj;
47600 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47601 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47602 return SWIG_Py_Void();
47603 }
47604
47605 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47606 return SWIG_Python_InitShadowInstance(args);
47607 }
47608
47609 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47610 PyObject *resultobj = 0;
47611 wxSizer *arg1 = (wxSizer *) 0 ;
47612 void *argp1 = 0 ;
47613 int res1 = 0 ;
47614 PyObject *swig_obj[1] ;
47615
47616 if (!args) SWIG_fail;
47617 swig_obj[0] = args;
47618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47619 if (!SWIG_IsOK(res1)) {
47620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47621 }
47622 arg1 = reinterpret_cast< wxSizer * >(argp1);
47623 {
47624 PyThreadState* __tstate = wxPyBeginAllowThreads();
47625 delete arg1;
47626
47627 wxPyEndAllowThreads(__tstate);
47628 if (PyErr_Occurred()) SWIG_fail;
47629 }
47630 resultobj = SWIG_Py_Void();
47631 return resultobj;
47632 fail:
47633 return NULL;
47634 }
47635
47636
47637 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47638 PyObject *resultobj = 0;
47639 wxSizer *arg1 = (wxSizer *) 0 ;
47640 PyObject *arg2 = (PyObject *) 0 ;
47641 void *argp1 = 0 ;
47642 int res1 = 0 ;
47643 PyObject * obj0 = 0 ;
47644 PyObject * obj1 = 0 ;
47645 char * kwnames[] = {
47646 (char *) "self",(char *) "_self", NULL
47647 };
47648
47649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47651 if (!SWIG_IsOK(res1)) {
47652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47653 }
47654 arg1 = reinterpret_cast< wxSizer * >(argp1);
47655 arg2 = obj1;
47656 {
47657 PyThreadState* __tstate = wxPyBeginAllowThreads();
47658 wxSizer__setOORInfo(arg1,arg2);
47659 wxPyEndAllowThreads(__tstate);
47660 if (PyErr_Occurred()) SWIG_fail;
47661 }
47662 resultobj = SWIG_Py_Void();
47663 return resultobj;
47664 fail:
47665 return NULL;
47666 }
47667
47668
47669 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47670 PyObject *resultobj = 0;
47671 wxSizer *arg1 = (wxSizer *) 0 ;
47672 PyObject *arg2 = (PyObject *) 0 ;
47673 int arg3 = (int) 0 ;
47674 int arg4 = (int) 0 ;
47675 int arg5 = (int) 0 ;
47676 PyObject *arg6 = (PyObject *) NULL ;
47677 wxSizerItem *result = 0 ;
47678 void *argp1 = 0 ;
47679 int res1 = 0 ;
47680 int val3 ;
47681 int ecode3 = 0 ;
47682 int val4 ;
47683 int ecode4 = 0 ;
47684 int val5 ;
47685 int ecode5 = 0 ;
47686 PyObject * obj0 = 0 ;
47687 PyObject * obj1 = 0 ;
47688 PyObject * obj2 = 0 ;
47689 PyObject * obj3 = 0 ;
47690 PyObject * obj4 = 0 ;
47691 PyObject * obj5 = 0 ;
47692 char * kwnames[] = {
47693 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47694 };
47695
47696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47698 if (!SWIG_IsOK(res1)) {
47699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47700 }
47701 arg1 = reinterpret_cast< wxSizer * >(argp1);
47702 arg2 = obj1;
47703 if (obj2) {
47704 ecode3 = SWIG_AsVal_int(obj2, &val3);
47705 if (!SWIG_IsOK(ecode3)) {
47706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47707 }
47708 arg3 = static_cast< int >(val3);
47709 }
47710 if (obj3) {
47711 ecode4 = SWIG_AsVal_int(obj3, &val4);
47712 if (!SWIG_IsOK(ecode4)) {
47713 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47714 }
47715 arg4 = static_cast< int >(val4);
47716 }
47717 if (obj4) {
47718 ecode5 = SWIG_AsVal_int(obj4, &val5);
47719 if (!SWIG_IsOK(ecode5)) {
47720 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47721 }
47722 arg5 = static_cast< int >(val5);
47723 }
47724 if (obj5) {
47725 arg6 = obj5;
47726 }
47727 {
47728 PyThreadState* __tstate = wxPyBeginAllowThreads();
47729 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47730 wxPyEndAllowThreads(__tstate);
47731 if (PyErr_Occurred()) SWIG_fail;
47732 }
47733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47734 return resultobj;
47735 fail:
47736 return NULL;
47737 }
47738
47739
47740 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47741 PyObject *resultobj = 0;
47742 wxSizer *arg1 = (wxSizer *) 0 ;
47743 int arg2 ;
47744 PyObject *arg3 = (PyObject *) 0 ;
47745 int arg4 = (int) 0 ;
47746 int arg5 = (int) 0 ;
47747 int arg6 = (int) 0 ;
47748 PyObject *arg7 = (PyObject *) NULL ;
47749 wxSizerItem *result = 0 ;
47750 void *argp1 = 0 ;
47751 int res1 = 0 ;
47752 int val2 ;
47753 int ecode2 = 0 ;
47754 int val4 ;
47755 int ecode4 = 0 ;
47756 int val5 ;
47757 int ecode5 = 0 ;
47758 int val6 ;
47759 int ecode6 = 0 ;
47760 PyObject * obj0 = 0 ;
47761 PyObject * obj1 = 0 ;
47762 PyObject * obj2 = 0 ;
47763 PyObject * obj3 = 0 ;
47764 PyObject * obj4 = 0 ;
47765 PyObject * obj5 = 0 ;
47766 PyObject * obj6 = 0 ;
47767 char * kwnames[] = {
47768 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47769 };
47770
47771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47773 if (!SWIG_IsOK(res1)) {
47774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47775 }
47776 arg1 = reinterpret_cast< wxSizer * >(argp1);
47777 ecode2 = SWIG_AsVal_int(obj1, &val2);
47778 if (!SWIG_IsOK(ecode2)) {
47779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47780 }
47781 arg2 = static_cast< int >(val2);
47782 arg3 = obj2;
47783 if (obj3) {
47784 ecode4 = SWIG_AsVal_int(obj3, &val4);
47785 if (!SWIG_IsOK(ecode4)) {
47786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47787 }
47788 arg4 = static_cast< int >(val4);
47789 }
47790 if (obj4) {
47791 ecode5 = SWIG_AsVal_int(obj4, &val5);
47792 if (!SWIG_IsOK(ecode5)) {
47793 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47794 }
47795 arg5 = static_cast< int >(val5);
47796 }
47797 if (obj5) {
47798 ecode6 = SWIG_AsVal_int(obj5, &val6);
47799 if (!SWIG_IsOK(ecode6)) {
47800 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47801 }
47802 arg6 = static_cast< int >(val6);
47803 }
47804 if (obj6) {
47805 arg7 = obj6;
47806 }
47807 {
47808 PyThreadState* __tstate = wxPyBeginAllowThreads();
47809 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47810 wxPyEndAllowThreads(__tstate);
47811 if (PyErr_Occurred()) SWIG_fail;
47812 }
47813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47814 return resultobj;
47815 fail:
47816 return NULL;
47817 }
47818
47819
47820 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47821 PyObject *resultobj = 0;
47822 wxSizer *arg1 = (wxSizer *) 0 ;
47823 PyObject *arg2 = (PyObject *) 0 ;
47824 int arg3 = (int) 0 ;
47825 int arg4 = (int) 0 ;
47826 int arg5 = (int) 0 ;
47827 PyObject *arg6 = (PyObject *) NULL ;
47828 wxSizerItem *result = 0 ;
47829 void *argp1 = 0 ;
47830 int res1 = 0 ;
47831 int val3 ;
47832 int ecode3 = 0 ;
47833 int val4 ;
47834 int ecode4 = 0 ;
47835 int val5 ;
47836 int ecode5 = 0 ;
47837 PyObject * obj0 = 0 ;
47838 PyObject * obj1 = 0 ;
47839 PyObject * obj2 = 0 ;
47840 PyObject * obj3 = 0 ;
47841 PyObject * obj4 = 0 ;
47842 PyObject * obj5 = 0 ;
47843 char * kwnames[] = {
47844 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47845 };
47846
47847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47849 if (!SWIG_IsOK(res1)) {
47850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47851 }
47852 arg1 = reinterpret_cast< wxSizer * >(argp1);
47853 arg2 = obj1;
47854 if (obj2) {
47855 ecode3 = SWIG_AsVal_int(obj2, &val3);
47856 if (!SWIG_IsOK(ecode3)) {
47857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47858 }
47859 arg3 = static_cast< int >(val3);
47860 }
47861 if (obj3) {
47862 ecode4 = SWIG_AsVal_int(obj3, &val4);
47863 if (!SWIG_IsOK(ecode4)) {
47864 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47865 }
47866 arg4 = static_cast< int >(val4);
47867 }
47868 if (obj4) {
47869 ecode5 = SWIG_AsVal_int(obj4, &val5);
47870 if (!SWIG_IsOK(ecode5)) {
47871 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47872 }
47873 arg5 = static_cast< int >(val5);
47874 }
47875 if (obj5) {
47876 arg6 = obj5;
47877 }
47878 {
47879 PyThreadState* __tstate = wxPyBeginAllowThreads();
47880 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47881 wxPyEndAllowThreads(__tstate);
47882 if (PyErr_Occurred()) SWIG_fail;
47883 }
47884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47885 return resultobj;
47886 fail:
47887 return NULL;
47888 }
47889
47890
47891 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47892 PyObject *resultobj = 0;
47893 wxSizer *arg1 = (wxSizer *) 0 ;
47894 PyObject *arg2 = (PyObject *) 0 ;
47895 bool result;
47896 void *argp1 = 0 ;
47897 int res1 = 0 ;
47898 PyObject * obj0 = 0 ;
47899 PyObject * obj1 = 0 ;
47900 char * kwnames[] = {
47901 (char *) "self",(char *) "item", NULL
47902 };
47903
47904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47906 if (!SWIG_IsOK(res1)) {
47907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47908 }
47909 arg1 = reinterpret_cast< wxSizer * >(argp1);
47910 arg2 = obj1;
47911 {
47912 PyThreadState* __tstate = wxPyBeginAllowThreads();
47913 result = (bool)wxSizer_Remove(arg1,arg2);
47914 wxPyEndAllowThreads(__tstate);
47915 if (PyErr_Occurred()) SWIG_fail;
47916 }
47917 {
47918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47919 }
47920 return resultobj;
47921 fail:
47922 return NULL;
47923 }
47924
47925
47926 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47927 PyObject *resultobj = 0;
47928 wxSizer *arg1 = (wxSizer *) 0 ;
47929 PyObject *arg2 = (PyObject *) 0 ;
47930 bool result;
47931 void *argp1 = 0 ;
47932 int res1 = 0 ;
47933 PyObject * obj0 = 0 ;
47934 PyObject * obj1 = 0 ;
47935 char * kwnames[] = {
47936 (char *) "self",(char *) "item", NULL
47937 };
47938
47939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47941 if (!SWIG_IsOK(res1)) {
47942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47943 }
47944 arg1 = reinterpret_cast< wxSizer * >(argp1);
47945 arg2 = obj1;
47946 {
47947 PyThreadState* __tstate = wxPyBeginAllowThreads();
47948 result = (bool)wxSizer_Detach(arg1,arg2);
47949 wxPyEndAllowThreads(__tstate);
47950 if (PyErr_Occurred()) SWIG_fail;
47951 }
47952 {
47953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47954 }
47955 return resultobj;
47956 fail:
47957 return NULL;
47958 }
47959
47960
47961 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47962 PyObject *resultobj = 0;
47963 wxSizer *arg1 = (wxSizer *) 0 ;
47964 PyObject *arg2 = (PyObject *) 0 ;
47965 wxSizerItem *result = 0 ;
47966 void *argp1 = 0 ;
47967 int res1 = 0 ;
47968 PyObject * obj0 = 0 ;
47969 PyObject * obj1 = 0 ;
47970 char * kwnames[] = {
47971 (char *) "self",(char *) "item", NULL
47972 };
47973
47974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47976 if (!SWIG_IsOK(res1)) {
47977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47978 }
47979 arg1 = reinterpret_cast< wxSizer * >(argp1);
47980 arg2 = obj1;
47981 {
47982 PyThreadState* __tstate = wxPyBeginAllowThreads();
47983 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47984 wxPyEndAllowThreads(__tstate);
47985 if (PyErr_Occurred()) SWIG_fail;
47986 }
47987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47988 return resultobj;
47989 fail:
47990 return NULL;
47991 }
47992
47993
47994 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47995 PyObject *resultobj = 0;
47996 wxSizer *arg1 = (wxSizer *) 0 ;
47997 PyObject *arg2 = (PyObject *) 0 ;
47998 wxSize *arg3 = 0 ;
47999 void *argp1 = 0 ;
48000 int res1 = 0 ;
48001 wxSize temp3 ;
48002 PyObject * obj0 = 0 ;
48003 PyObject * obj1 = 0 ;
48004 PyObject * obj2 = 0 ;
48005 char * kwnames[] = {
48006 (char *) "self",(char *) "item",(char *) "size", NULL
48007 };
48008
48009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48011 if (!SWIG_IsOK(res1)) {
48012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48013 }
48014 arg1 = reinterpret_cast< wxSizer * >(argp1);
48015 arg2 = obj1;
48016 {
48017 arg3 = &temp3;
48018 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48019 }
48020 {
48021 PyThreadState* __tstate = wxPyBeginAllowThreads();
48022 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
48023 wxPyEndAllowThreads(__tstate);
48024 if (PyErr_Occurred()) SWIG_fail;
48025 }
48026 resultobj = SWIG_Py_Void();
48027 return resultobj;
48028 fail:
48029 return NULL;
48030 }
48031
48032
48033 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48034 PyObject *resultobj = 0;
48035 wxSizer *arg1 = (wxSizer *) 0 ;
48036 wxWindow *arg2 = (wxWindow *) 0 ;
48037 wxWindow *arg3 = (wxWindow *) 0 ;
48038 bool arg4 = (bool) false ;
48039 bool result;
48040 void *argp1 = 0 ;
48041 int res1 = 0 ;
48042 void *argp2 = 0 ;
48043 int res2 = 0 ;
48044 void *argp3 = 0 ;
48045 int res3 = 0 ;
48046 bool val4 ;
48047 int ecode4 = 0 ;
48048 PyObject * obj0 = 0 ;
48049 PyObject * obj1 = 0 ;
48050 PyObject * obj2 = 0 ;
48051 PyObject * obj3 = 0 ;
48052 char * kwnames[] = {
48053 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
48054 };
48055
48056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48058 if (!SWIG_IsOK(res1)) {
48059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
48060 }
48061 arg1 = reinterpret_cast< wxSizer * >(argp1);
48062 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48063 if (!SWIG_IsOK(res2)) {
48064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
48065 }
48066 arg2 = reinterpret_cast< wxWindow * >(argp2);
48067 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
48068 if (!SWIG_IsOK(res3)) {
48069 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
48070 }
48071 arg3 = reinterpret_cast< wxWindow * >(argp3);
48072 if (obj3) {
48073 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48074 if (!SWIG_IsOK(ecode4)) {
48075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
48076 }
48077 arg4 = static_cast< bool >(val4);
48078 }
48079 {
48080 PyThreadState* __tstate = wxPyBeginAllowThreads();
48081 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48082 wxPyEndAllowThreads(__tstate);
48083 if (PyErr_Occurred()) SWIG_fail;
48084 }
48085 {
48086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48087 }
48088 return resultobj;
48089 fail:
48090 return NULL;
48091 }
48092
48093
48094 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48095 PyObject *resultobj = 0;
48096 wxSizer *arg1 = (wxSizer *) 0 ;
48097 wxSizer *arg2 = (wxSizer *) 0 ;
48098 wxSizer *arg3 = (wxSizer *) 0 ;
48099 bool arg4 = (bool) false ;
48100 bool result;
48101 void *argp1 = 0 ;
48102 int res1 = 0 ;
48103 void *argp2 = 0 ;
48104 int res2 = 0 ;
48105 void *argp3 = 0 ;
48106 int res3 = 0 ;
48107 bool val4 ;
48108 int ecode4 = 0 ;
48109 PyObject * obj0 = 0 ;
48110 PyObject * obj1 = 0 ;
48111 PyObject * obj2 = 0 ;
48112 PyObject * obj3 = 0 ;
48113 char * kwnames[] = {
48114 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
48115 };
48116
48117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48119 if (!SWIG_IsOK(res1)) {
48120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48121 }
48122 arg1 = reinterpret_cast< wxSizer * >(argp1);
48123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
48124 if (!SWIG_IsOK(res2)) {
48125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
48126 }
48127 arg2 = reinterpret_cast< wxSizer * >(argp2);
48128 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
48129 if (!SWIG_IsOK(res3)) {
48130 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
48131 }
48132 arg3 = reinterpret_cast< wxSizer * >(argp3);
48133 if (obj3) {
48134 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48135 if (!SWIG_IsOK(ecode4)) {
48136 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
48137 }
48138 arg4 = static_cast< bool >(val4);
48139 }
48140 {
48141 PyThreadState* __tstate = wxPyBeginAllowThreads();
48142 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48143 wxPyEndAllowThreads(__tstate);
48144 if (PyErr_Occurred()) SWIG_fail;
48145 }
48146 {
48147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48148 }
48149 return resultobj;
48150 fail:
48151 return NULL;
48152 }
48153
48154
48155 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48156 PyObject *resultobj = 0;
48157 wxSizer *arg1 = (wxSizer *) 0 ;
48158 size_t arg2 ;
48159 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48160 bool result;
48161 void *argp1 = 0 ;
48162 int res1 = 0 ;
48163 size_t val2 ;
48164 int ecode2 = 0 ;
48165 void *argp3 = 0 ;
48166 int res3 = 0 ;
48167 PyObject * obj0 = 0 ;
48168 PyObject * obj1 = 0 ;
48169 PyObject * obj2 = 0 ;
48170 char * kwnames[] = {
48171 (char *) "self",(char *) "index",(char *) "newitem", NULL
48172 };
48173
48174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48176 if (!SWIG_IsOK(res1)) {
48177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48178 }
48179 arg1 = reinterpret_cast< wxSizer * >(argp1);
48180 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48181 if (!SWIG_IsOK(ecode2)) {
48182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48183 }
48184 arg2 = static_cast< size_t >(val2);
48185 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48186 if (!SWIG_IsOK(res3)) {
48187 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48188 }
48189 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48190 {
48191 PyThreadState* __tstate = wxPyBeginAllowThreads();
48192 result = (bool)(arg1)->Replace(arg2,arg3);
48193 wxPyEndAllowThreads(__tstate);
48194 if (PyErr_Occurred()) SWIG_fail;
48195 }
48196 {
48197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48198 }
48199 return resultobj;
48200 fail:
48201 return NULL;
48202 }
48203
48204
48205 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48206 PyObject *resultobj = 0;
48207 wxSizer *arg1 = (wxSizer *) 0 ;
48208 wxWindow *arg2 = (wxWindow *) 0 ;
48209 void *argp1 = 0 ;
48210 int res1 = 0 ;
48211 void *argp2 = 0 ;
48212 int res2 = 0 ;
48213 PyObject * obj0 = 0 ;
48214 PyObject * obj1 = 0 ;
48215 char * kwnames[] = {
48216 (char *) "self",(char *) "window", NULL
48217 };
48218
48219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48221 if (!SWIG_IsOK(res1)) {
48222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48223 }
48224 arg1 = reinterpret_cast< wxSizer * >(argp1);
48225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48226 if (!SWIG_IsOK(res2)) {
48227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48228 }
48229 arg2 = reinterpret_cast< wxWindow * >(argp2);
48230 {
48231 PyThreadState* __tstate = wxPyBeginAllowThreads();
48232 (arg1)->SetContainingWindow(arg2);
48233 wxPyEndAllowThreads(__tstate);
48234 if (PyErr_Occurred()) SWIG_fail;
48235 }
48236 resultobj = SWIG_Py_Void();
48237 return resultobj;
48238 fail:
48239 return NULL;
48240 }
48241
48242
48243 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48244 PyObject *resultobj = 0;
48245 wxSizer *arg1 = (wxSizer *) 0 ;
48246 wxWindow *result = 0 ;
48247 void *argp1 = 0 ;
48248 int res1 = 0 ;
48249 PyObject *swig_obj[1] ;
48250
48251 if (!args) SWIG_fail;
48252 swig_obj[0] = args;
48253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48254 if (!SWIG_IsOK(res1)) {
48255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48256 }
48257 arg1 = reinterpret_cast< wxSizer * >(argp1);
48258 {
48259 PyThreadState* __tstate = wxPyBeginAllowThreads();
48260 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48261 wxPyEndAllowThreads(__tstate);
48262 if (PyErr_Occurred()) SWIG_fail;
48263 }
48264 {
48265 resultobj = wxPyMake_wxObject(result, 0);
48266 }
48267 return resultobj;
48268 fail:
48269 return NULL;
48270 }
48271
48272
48273 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48274 PyObject *resultobj = 0;
48275 wxSizer *arg1 = (wxSizer *) 0 ;
48276 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48277 wxSizerItem *result = 0 ;
48278 void *argp1 = 0 ;
48279 int res1 = 0 ;
48280 int res2 = 0 ;
48281 PyObject * obj0 = 0 ;
48282 PyObject * obj1 = 0 ;
48283 char * kwnames[] = {
48284 (char *) "self",(char *) "item", NULL
48285 };
48286
48287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48289 if (!SWIG_IsOK(res1)) {
48290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48291 }
48292 arg1 = reinterpret_cast< wxSizer * >(argp1);
48293 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48294 if (!SWIG_IsOK(res2)) {
48295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48296 }
48297 {
48298 PyThreadState* __tstate = wxPyBeginAllowThreads();
48299 result = (wxSizerItem *)(arg1)->Add(arg2);
48300 wxPyEndAllowThreads(__tstate);
48301 if (PyErr_Occurred()) SWIG_fail;
48302 }
48303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48304 return resultobj;
48305 fail:
48306 return NULL;
48307 }
48308
48309
48310 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48311 PyObject *resultobj = 0;
48312 wxSizer *arg1 = (wxSizer *) 0 ;
48313 size_t arg2 ;
48314 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48315 wxSizerItem *result = 0 ;
48316 void *argp1 = 0 ;
48317 int res1 = 0 ;
48318 size_t val2 ;
48319 int ecode2 = 0 ;
48320 int res3 = 0 ;
48321 PyObject * obj0 = 0 ;
48322 PyObject * obj1 = 0 ;
48323 PyObject * obj2 = 0 ;
48324 char * kwnames[] = {
48325 (char *) "self",(char *) "index",(char *) "item", NULL
48326 };
48327
48328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48330 if (!SWIG_IsOK(res1)) {
48331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48332 }
48333 arg1 = reinterpret_cast< wxSizer * >(argp1);
48334 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48335 if (!SWIG_IsOK(ecode2)) {
48336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48337 }
48338 arg2 = static_cast< size_t >(val2);
48339 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48340 if (!SWIG_IsOK(res3)) {
48341 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48342 }
48343 {
48344 PyThreadState* __tstate = wxPyBeginAllowThreads();
48345 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48346 wxPyEndAllowThreads(__tstate);
48347 if (PyErr_Occurred()) SWIG_fail;
48348 }
48349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48350 return resultobj;
48351 fail:
48352 return NULL;
48353 }
48354
48355
48356 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48357 PyObject *resultobj = 0;
48358 wxSizer *arg1 = (wxSizer *) 0 ;
48359 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48360 wxSizerItem *result = 0 ;
48361 void *argp1 = 0 ;
48362 int res1 = 0 ;
48363 int res2 = 0 ;
48364 PyObject * obj0 = 0 ;
48365 PyObject * obj1 = 0 ;
48366 char * kwnames[] = {
48367 (char *) "self",(char *) "item", NULL
48368 };
48369
48370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48372 if (!SWIG_IsOK(res1)) {
48373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48374 }
48375 arg1 = reinterpret_cast< wxSizer * >(argp1);
48376 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48377 if (!SWIG_IsOK(res2)) {
48378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48379 }
48380 {
48381 PyThreadState* __tstate = wxPyBeginAllowThreads();
48382 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48383 wxPyEndAllowThreads(__tstate);
48384 if (PyErr_Occurred()) SWIG_fail;
48385 }
48386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48387 return resultobj;
48388 fail:
48389 return NULL;
48390 }
48391
48392
48393 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48394 PyObject *resultobj = 0;
48395 wxSizer *arg1 = (wxSizer *) 0 ;
48396 int arg2 ;
48397 int arg3 ;
48398 int arg4 ;
48399 int arg5 ;
48400 void *argp1 = 0 ;
48401 int res1 = 0 ;
48402 int val2 ;
48403 int ecode2 = 0 ;
48404 int val3 ;
48405 int ecode3 = 0 ;
48406 int val4 ;
48407 int ecode4 = 0 ;
48408 int val5 ;
48409 int ecode5 = 0 ;
48410 PyObject * obj0 = 0 ;
48411 PyObject * obj1 = 0 ;
48412 PyObject * obj2 = 0 ;
48413 PyObject * obj3 = 0 ;
48414 PyObject * obj4 = 0 ;
48415 char * kwnames[] = {
48416 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48417 };
48418
48419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48421 if (!SWIG_IsOK(res1)) {
48422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48423 }
48424 arg1 = reinterpret_cast< wxSizer * >(argp1);
48425 ecode2 = SWIG_AsVal_int(obj1, &val2);
48426 if (!SWIG_IsOK(ecode2)) {
48427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48428 }
48429 arg2 = static_cast< int >(val2);
48430 ecode3 = SWIG_AsVal_int(obj2, &val3);
48431 if (!SWIG_IsOK(ecode3)) {
48432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48433 }
48434 arg3 = static_cast< int >(val3);
48435 ecode4 = SWIG_AsVal_int(obj3, &val4);
48436 if (!SWIG_IsOK(ecode4)) {
48437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48438 }
48439 arg4 = static_cast< int >(val4);
48440 ecode5 = SWIG_AsVal_int(obj4, &val5);
48441 if (!SWIG_IsOK(ecode5)) {
48442 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48443 }
48444 arg5 = static_cast< int >(val5);
48445 {
48446 PyThreadState* __tstate = wxPyBeginAllowThreads();
48447 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48448 wxPyEndAllowThreads(__tstate);
48449 if (PyErr_Occurred()) SWIG_fail;
48450 }
48451 resultobj = SWIG_Py_Void();
48452 return resultobj;
48453 fail:
48454 return NULL;
48455 }
48456
48457
48458 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48459 PyObject *resultobj = 0;
48460 wxSizer *arg1 = (wxSizer *) 0 ;
48461 wxSize *arg2 = 0 ;
48462 void *argp1 = 0 ;
48463 int res1 = 0 ;
48464 wxSize temp2 ;
48465 PyObject * obj0 = 0 ;
48466 PyObject * obj1 = 0 ;
48467 char * kwnames[] = {
48468 (char *) "self",(char *) "size", NULL
48469 };
48470
48471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48473 if (!SWIG_IsOK(res1)) {
48474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48475 }
48476 arg1 = reinterpret_cast< wxSizer * >(argp1);
48477 {
48478 arg2 = &temp2;
48479 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48480 }
48481 {
48482 PyThreadState* __tstate = wxPyBeginAllowThreads();
48483 (arg1)->SetMinSize((wxSize const &)*arg2);
48484 wxPyEndAllowThreads(__tstate);
48485 if (PyErr_Occurred()) SWIG_fail;
48486 }
48487 resultobj = SWIG_Py_Void();
48488 return resultobj;
48489 fail:
48490 return NULL;
48491 }
48492
48493
48494 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48495 PyObject *resultobj = 0;
48496 wxSizer *arg1 = (wxSizer *) 0 ;
48497 wxSize result;
48498 void *argp1 = 0 ;
48499 int res1 = 0 ;
48500 PyObject *swig_obj[1] ;
48501
48502 if (!args) SWIG_fail;
48503 swig_obj[0] = args;
48504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48505 if (!SWIG_IsOK(res1)) {
48506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48507 }
48508 arg1 = reinterpret_cast< wxSizer * >(argp1);
48509 {
48510 PyThreadState* __tstate = wxPyBeginAllowThreads();
48511 result = (arg1)->GetSize();
48512 wxPyEndAllowThreads(__tstate);
48513 if (PyErr_Occurred()) SWIG_fail;
48514 }
48515 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48516 return resultobj;
48517 fail:
48518 return NULL;
48519 }
48520
48521
48522 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48523 PyObject *resultobj = 0;
48524 wxSizer *arg1 = (wxSizer *) 0 ;
48525 wxPoint result;
48526 void *argp1 = 0 ;
48527 int res1 = 0 ;
48528 PyObject *swig_obj[1] ;
48529
48530 if (!args) SWIG_fail;
48531 swig_obj[0] = args;
48532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48533 if (!SWIG_IsOK(res1)) {
48534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48535 }
48536 arg1 = reinterpret_cast< wxSizer * >(argp1);
48537 {
48538 PyThreadState* __tstate = wxPyBeginAllowThreads();
48539 result = (arg1)->GetPosition();
48540 wxPyEndAllowThreads(__tstate);
48541 if (PyErr_Occurred()) SWIG_fail;
48542 }
48543 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48544 return resultobj;
48545 fail:
48546 return NULL;
48547 }
48548
48549
48550 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48551 PyObject *resultobj = 0;
48552 wxSizer *arg1 = (wxSizer *) 0 ;
48553 wxSize result;
48554 void *argp1 = 0 ;
48555 int res1 = 0 ;
48556 PyObject *swig_obj[1] ;
48557
48558 if (!args) SWIG_fail;
48559 swig_obj[0] = args;
48560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48561 if (!SWIG_IsOK(res1)) {
48562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48563 }
48564 arg1 = reinterpret_cast< wxSizer * >(argp1);
48565 {
48566 PyThreadState* __tstate = wxPyBeginAllowThreads();
48567 result = (arg1)->GetMinSize();
48568 wxPyEndAllowThreads(__tstate);
48569 if (PyErr_Occurred()) SWIG_fail;
48570 }
48571 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48572 return resultobj;
48573 fail:
48574 return NULL;
48575 }
48576
48577
48578 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48579 PyObject *resultobj = 0;
48580 wxSizer *arg1 = (wxSizer *) 0 ;
48581 void *argp1 = 0 ;
48582 int res1 = 0 ;
48583 PyObject *swig_obj[1] ;
48584
48585 if (!args) SWIG_fail;
48586 swig_obj[0] = args;
48587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48588 if (!SWIG_IsOK(res1)) {
48589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48590 }
48591 arg1 = reinterpret_cast< wxSizer * >(argp1);
48592 {
48593 PyThreadState* __tstate = wxPyBeginAllowThreads();
48594 (arg1)->RecalcSizes();
48595 wxPyEndAllowThreads(__tstate);
48596 if (PyErr_Occurred()) SWIG_fail;
48597 }
48598 resultobj = SWIG_Py_Void();
48599 return resultobj;
48600 fail:
48601 return NULL;
48602 }
48603
48604
48605 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48606 PyObject *resultobj = 0;
48607 wxSizer *arg1 = (wxSizer *) 0 ;
48608 wxSize result;
48609 void *argp1 = 0 ;
48610 int res1 = 0 ;
48611 PyObject *swig_obj[1] ;
48612
48613 if (!args) SWIG_fail;
48614 swig_obj[0] = args;
48615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48616 if (!SWIG_IsOK(res1)) {
48617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48618 }
48619 arg1 = reinterpret_cast< wxSizer * >(argp1);
48620 {
48621 PyThreadState* __tstate = wxPyBeginAllowThreads();
48622 result = (arg1)->CalcMin();
48623 wxPyEndAllowThreads(__tstate);
48624 if (PyErr_Occurred()) SWIG_fail;
48625 }
48626 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48627 return resultobj;
48628 fail:
48629 return NULL;
48630 }
48631
48632
48633 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48634 PyObject *resultobj = 0;
48635 wxSizer *arg1 = (wxSizer *) 0 ;
48636 void *argp1 = 0 ;
48637 int res1 = 0 ;
48638 PyObject *swig_obj[1] ;
48639
48640 if (!args) SWIG_fail;
48641 swig_obj[0] = args;
48642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48643 if (!SWIG_IsOK(res1)) {
48644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48645 }
48646 arg1 = reinterpret_cast< wxSizer * >(argp1);
48647 {
48648 PyThreadState* __tstate = wxPyBeginAllowThreads();
48649 (arg1)->Layout();
48650 wxPyEndAllowThreads(__tstate);
48651 if (PyErr_Occurred()) SWIG_fail;
48652 }
48653 resultobj = SWIG_Py_Void();
48654 return resultobj;
48655 fail:
48656 return NULL;
48657 }
48658
48659
48660 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48661 PyObject *resultobj = 0;
48662 wxSizer *arg1 = (wxSizer *) 0 ;
48663 wxWindow *arg2 = (wxWindow *) 0 ;
48664 wxSize result;
48665 void *argp1 = 0 ;
48666 int res1 = 0 ;
48667 void *argp2 = 0 ;
48668 int res2 = 0 ;
48669 PyObject * obj0 = 0 ;
48670 PyObject * obj1 = 0 ;
48671 char * kwnames[] = {
48672 (char *) "self",(char *) "window", NULL
48673 };
48674
48675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48677 if (!SWIG_IsOK(res1)) {
48678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48679 }
48680 arg1 = reinterpret_cast< wxSizer * >(argp1);
48681 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48682 if (!SWIG_IsOK(res2)) {
48683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48684 }
48685 arg2 = reinterpret_cast< wxWindow * >(argp2);
48686 {
48687 PyThreadState* __tstate = wxPyBeginAllowThreads();
48688 result = (arg1)->Fit(arg2);
48689 wxPyEndAllowThreads(__tstate);
48690 if (PyErr_Occurred()) SWIG_fail;
48691 }
48692 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48693 return resultobj;
48694 fail:
48695 return NULL;
48696 }
48697
48698
48699 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48700 PyObject *resultobj = 0;
48701 wxSizer *arg1 = (wxSizer *) 0 ;
48702 wxWindow *arg2 = (wxWindow *) 0 ;
48703 void *argp1 = 0 ;
48704 int res1 = 0 ;
48705 void *argp2 = 0 ;
48706 int res2 = 0 ;
48707 PyObject * obj0 = 0 ;
48708 PyObject * obj1 = 0 ;
48709 char * kwnames[] = {
48710 (char *) "self",(char *) "window", NULL
48711 };
48712
48713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48715 if (!SWIG_IsOK(res1)) {
48716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48717 }
48718 arg1 = reinterpret_cast< wxSizer * >(argp1);
48719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48720 if (!SWIG_IsOK(res2)) {
48721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48722 }
48723 arg2 = reinterpret_cast< wxWindow * >(argp2);
48724 {
48725 PyThreadState* __tstate = wxPyBeginAllowThreads();
48726 (arg1)->FitInside(arg2);
48727 wxPyEndAllowThreads(__tstate);
48728 if (PyErr_Occurred()) SWIG_fail;
48729 }
48730 resultobj = SWIG_Py_Void();
48731 return resultobj;
48732 fail:
48733 return NULL;
48734 }
48735
48736
48737 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48738 PyObject *resultobj = 0;
48739 wxSizer *arg1 = (wxSizer *) 0 ;
48740 wxWindow *arg2 = (wxWindow *) 0 ;
48741 void *argp1 = 0 ;
48742 int res1 = 0 ;
48743 void *argp2 = 0 ;
48744 int res2 = 0 ;
48745 PyObject * obj0 = 0 ;
48746 PyObject * obj1 = 0 ;
48747 char * kwnames[] = {
48748 (char *) "self",(char *) "window", NULL
48749 };
48750
48751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48753 if (!SWIG_IsOK(res1)) {
48754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48755 }
48756 arg1 = reinterpret_cast< wxSizer * >(argp1);
48757 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48758 if (!SWIG_IsOK(res2)) {
48759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48760 }
48761 arg2 = reinterpret_cast< wxWindow * >(argp2);
48762 {
48763 PyThreadState* __tstate = wxPyBeginAllowThreads();
48764 (arg1)->SetSizeHints(arg2);
48765 wxPyEndAllowThreads(__tstate);
48766 if (PyErr_Occurred()) SWIG_fail;
48767 }
48768 resultobj = SWIG_Py_Void();
48769 return resultobj;
48770 fail:
48771 return NULL;
48772 }
48773
48774
48775 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48776 PyObject *resultobj = 0;
48777 wxSizer *arg1 = (wxSizer *) 0 ;
48778 wxWindow *arg2 = (wxWindow *) 0 ;
48779 void *argp1 = 0 ;
48780 int res1 = 0 ;
48781 void *argp2 = 0 ;
48782 int res2 = 0 ;
48783 PyObject * obj0 = 0 ;
48784 PyObject * obj1 = 0 ;
48785 char * kwnames[] = {
48786 (char *) "self",(char *) "window", NULL
48787 };
48788
48789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48791 if (!SWIG_IsOK(res1)) {
48792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48793 }
48794 arg1 = reinterpret_cast< wxSizer * >(argp1);
48795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48796 if (!SWIG_IsOK(res2)) {
48797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48798 }
48799 arg2 = reinterpret_cast< wxWindow * >(argp2);
48800 {
48801 PyThreadState* __tstate = wxPyBeginAllowThreads();
48802 (arg1)->SetVirtualSizeHints(arg2);
48803 wxPyEndAllowThreads(__tstate);
48804 if (PyErr_Occurred()) SWIG_fail;
48805 }
48806 resultobj = SWIG_Py_Void();
48807 return resultobj;
48808 fail:
48809 return NULL;
48810 }
48811
48812
48813 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48814 PyObject *resultobj = 0;
48815 wxSizer *arg1 = (wxSizer *) 0 ;
48816 bool arg2 = (bool) false ;
48817 void *argp1 = 0 ;
48818 int res1 = 0 ;
48819 bool val2 ;
48820 int ecode2 = 0 ;
48821 PyObject * obj0 = 0 ;
48822 PyObject * obj1 = 0 ;
48823 char * kwnames[] = {
48824 (char *) "self",(char *) "deleteWindows", NULL
48825 };
48826
48827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48829 if (!SWIG_IsOK(res1)) {
48830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48831 }
48832 arg1 = reinterpret_cast< wxSizer * >(argp1);
48833 if (obj1) {
48834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48835 if (!SWIG_IsOK(ecode2)) {
48836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48837 }
48838 arg2 = static_cast< bool >(val2);
48839 }
48840 {
48841 PyThreadState* __tstate = wxPyBeginAllowThreads();
48842 (arg1)->Clear(arg2);
48843 wxPyEndAllowThreads(__tstate);
48844 if (PyErr_Occurred()) SWIG_fail;
48845 }
48846 resultobj = SWIG_Py_Void();
48847 return resultobj;
48848 fail:
48849 return NULL;
48850 }
48851
48852
48853 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48854 PyObject *resultobj = 0;
48855 wxSizer *arg1 = (wxSizer *) 0 ;
48856 void *argp1 = 0 ;
48857 int res1 = 0 ;
48858 PyObject *swig_obj[1] ;
48859
48860 if (!args) SWIG_fail;
48861 swig_obj[0] = args;
48862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48863 if (!SWIG_IsOK(res1)) {
48864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48865 }
48866 arg1 = reinterpret_cast< wxSizer * >(argp1);
48867 {
48868 PyThreadState* __tstate = wxPyBeginAllowThreads();
48869 (arg1)->DeleteWindows();
48870 wxPyEndAllowThreads(__tstate);
48871 if (PyErr_Occurred()) SWIG_fail;
48872 }
48873 resultobj = SWIG_Py_Void();
48874 return resultobj;
48875 fail:
48876 return NULL;
48877 }
48878
48879
48880 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48881 PyObject *resultobj = 0;
48882 wxSizer *arg1 = (wxSizer *) 0 ;
48883 PyObject *result = 0 ;
48884 void *argp1 = 0 ;
48885 int res1 = 0 ;
48886 PyObject *swig_obj[1] ;
48887
48888 if (!args) SWIG_fail;
48889 swig_obj[0] = args;
48890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48891 if (!SWIG_IsOK(res1)) {
48892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48893 }
48894 arg1 = reinterpret_cast< wxSizer * >(argp1);
48895 {
48896 PyThreadState* __tstate = wxPyBeginAllowThreads();
48897 result = (PyObject *)wxSizer_GetChildren(arg1);
48898 wxPyEndAllowThreads(__tstate);
48899 if (PyErr_Occurred()) SWIG_fail;
48900 }
48901 resultobj = result;
48902 return resultobj;
48903 fail:
48904 return NULL;
48905 }
48906
48907
48908 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48909 PyObject *resultobj = 0;
48910 wxSizer *arg1 = (wxSizer *) 0 ;
48911 PyObject *arg2 = (PyObject *) 0 ;
48912 bool arg3 = (bool) true ;
48913 bool arg4 = (bool) false ;
48914 bool result;
48915 void *argp1 = 0 ;
48916 int res1 = 0 ;
48917 bool val3 ;
48918 int ecode3 = 0 ;
48919 bool val4 ;
48920 int ecode4 = 0 ;
48921 PyObject * obj0 = 0 ;
48922 PyObject * obj1 = 0 ;
48923 PyObject * obj2 = 0 ;
48924 PyObject * obj3 = 0 ;
48925 char * kwnames[] = {
48926 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48927 };
48928
48929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48931 if (!SWIG_IsOK(res1)) {
48932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48933 }
48934 arg1 = reinterpret_cast< wxSizer * >(argp1);
48935 arg2 = obj1;
48936 if (obj2) {
48937 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48938 if (!SWIG_IsOK(ecode3)) {
48939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48940 }
48941 arg3 = static_cast< bool >(val3);
48942 }
48943 if (obj3) {
48944 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48945 if (!SWIG_IsOK(ecode4)) {
48946 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48947 }
48948 arg4 = static_cast< bool >(val4);
48949 }
48950 {
48951 PyThreadState* __tstate = wxPyBeginAllowThreads();
48952 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48953 wxPyEndAllowThreads(__tstate);
48954 if (PyErr_Occurred()) SWIG_fail;
48955 }
48956 {
48957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48958 }
48959 return resultobj;
48960 fail:
48961 return NULL;
48962 }
48963
48964
48965 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48966 PyObject *resultobj = 0;
48967 wxSizer *arg1 = (wxSizer *) 0 ;
48968 PyObject *arg2 = (PyObject *) 0 ;
48969 bool result;
48970 void *argp1 = 0 ;
48971 int res1 = 0 ;
48972 PyObject * obj0 = 0 ;
48973 PyObject * obj1 = 0 ;
48974 char * kwnames[] = {
48975 (char *) "self",(char *) "item", NULL
48976 };
48977
48978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48980 if (!SWIG_IsOK(res1)) {
48981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48982 }
48983 arg1 = reinterpret_cast< wxSizer * >(argp1);
48984 arg2 = obj1;
48985 {
48986 PyThreadState* __tstate = wxPyBeginAllowThreads();
48987 result = (bool)wxSizer_IsShown(arg1,arg2);
48988 wxPyEndAllowThreads(__tstate);
48989 if (PyErr_Occurred()) SWIG_fail;
48990 }
48991 {
48992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48993 }
48994 return resultobj;
48995 fail:
48996 return NULL;
48997 }
48998
48999
49000 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49001 PyObject *resultobj = 0;
49002 wxSizer *arg1 = (wxSizer *) 0 ;
49003 bool arg2 ;
49004 void *argp1 = 0 ;
49005 int res1 = 0 ;
49006 bool val2 ;
49007 int ecode2 = 0 ;
49008 PyObject * obj0 = 0 ;
49009 PyObject * obj1 = 0 ;
49010 char * kwnames[] = {
49011 (char *) "self",(char *) "show", NULL
49012 };
49013
49014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
49015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49016 if (!SWIG_IsOK(res1)) {
49017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
49018 }
49019 arg1 = reinterpret_cast< wxSizer * >(argp1);
49020 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49021 if (!SWIG_IsOK(ecode2)) {
49022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
49023 }
49024 arg2 = static_cast< bool >(val2);
49025 {
49026 PyThreadState* __tstate = wxPyBeginAllowThreads();
49027 (arg1)->ShowItems(arg2);
49028 wxPyEndAllowThreads(__tstate);
49029 if (PyErr_Occurred()) SWIG_fail;
49030 }
49031 resultobj = SWIG_Py_Void();
49032 return resultobj;
49033 fail:
49034 return NULL;
49035 }
49036
49037
49038 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49039 PyObject *obj;
49040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49041 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
49042 return SWIG_Py_Void();
49043 }
49044
49045 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49046 PyObject *resultobj = 0;
49047 wxPySizer *result = 0 ;
49048
49049 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
49050 {
49051 PyThreadState* __tstate = wxPyBeginAllowThreads();
49052 result = (wxPySizer *)new wxPySizer();
49053 wxPyEndAllowThreads(__tstate);
49054 if (PyErr_Occurred()) SWIG_fail;
49055 }
49056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
49057 return resultobj;
49058 fail:
49059 return NULL;
49060 }
49061
49062
49063 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49064 PyObject *resultobj = 0;
49065 wxPySizer *arg1 = (wxPySizer *) 0 ;
49066 PyObject *arg2 = (PyObject *) 0 ;
49067 PyObject *arg3 = (PyObject *) 0 ;
49068 void *argp1 = 0 ;
49069 int res1 = 0 ;
49070 PyObject * obj0 = 0 ;
49071 PyObject * obj1 = 0 ;
49072 PyObject * obj2 = 0 ;
49073 char * kwnames[] = {
49074 (char *) "self",(char *) "self",(char *) "_class", NULL
49075 };
49076
49077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
49079 if (!SWIG_IsOK(res1)) {
49080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
49081 }
49082 arg1 = reinterpret_cast< wxPySizer * >(argp1);
49083 arg2 = obj1;
49084 arg3 = obj2;
49085 {
49086 PyThreadState* __tstate = wxPyBeginAllowThreads();
49087 (arg1)->_setCallbackInfo(arg2,arg3);
49088 wxPyEndAllowThreads(__tstate);
49089 if (PyErr_Occurred()) SWIG_fail;
49090 }
49091 resultobj = SWIG_Py_Void();
49092 return resultobj;
49093 fail:
49094 return NULL;
49095 }
49096
49097
49098 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49099 PyObject *obj;
49100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49101 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
49102 return SWIG_Py_Void();
49103 }
49104
49105 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49106 return SWIG_Python_InitShadowInstance(args);
49107 }
49108
49109 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49110 PyObject *resultobj = 0;
49111 int arg1 = (int) wxHORIZONTAL ;
49112 wxBoxSizer *result = 0 ;
49113 int val1 ;
49114 int ecode1 = 0 ;
49115 PyObject * obj0 = 0 ;
49116 char * kwnames[] = {
49117 (char *) "orient", NULL
49118 };
49119
49120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
49121 if (obj0) {
49122 ecode1 = SWIG_AsVal_int(obj0, &val1);
49123 if (!SWIG_IsOK(ecode1)) {
49124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
49125 }
49126 arg1 = static_cast< int >(val1);
49127 }
49128 {
49129 PyThreadState* __tstate = wxPyBeginAllowThreads();
49130 result = (wxBoxSizer *)new wxBoxSizer(arg1);
49131 wxPyEndAllowThreads(__tstate);
49132 if (PyErr_Occurred()) SWIG_fail;
49133 }
49134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
49135 return resultobj;
49136 fail:
49137 return NULL;
49138 }
49139
49140
49141 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49142 PyObject *resultobj = 0;
49143 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49144 int result;
49145 void *argp1 = 0 ;
49146 int res1 = 0 ;
49147 PyObject *swig_obj[1] ;
49148
49149 if (!args) SWIG_fail;
49150 swig_obj[0] = args;
49151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49152 if (!SWIG_IsOK(res1)) {
49153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49154 }
49155 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49156 {
49157 PyThreadState* __tstate = wxPyBeginAllowThreads();
49158 result = (int)(arg1)->GetOrientation();
49159 wxPyEndAllowThreads(__tstate);
49160 if (PyErr_Occurred()) SWIG_fail;
49161 }
49162 resultobj = SWIG_From_int(static_cast< int >(result));
49163 return resultobj;
49164 fail:
49165 return NULL;
49166 }
49167
49168
49169 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49170 PyObject *resultobj = 0;
49171 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49172 int arg2 ;
49173 void *argp1 = 0 ;
49174 int res1 = 0 ;
49175 int val2 ;
49176 int ecode2 = 0 ;
49177 PyObject * obj0 = 0 ;
49178 PyObject * obj1 = 0 ;
49179 char * kwnames[] = {
49180 (char *) "self",(char *) "orient", NULL
49181 };
49182
49183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49185 if (!SWIG_IsOK(res1)) {
49186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49187 }
49188 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49189 ecode2 = SWIG_AsVal_int(obj1, &val2);
49190 if (!SWIG_IsOK(ecode2)) {
49191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49192 }
49193 arg2 = static_cast< int >(val2);
49194 {
49195 PyThreadState* __tstate = wxPyBeginAllowThreads();
49196 (arg1)->SetOrientation(arg2);
49197 wxPyEndAllowThreads(__tstate);
49198 if (PyErr_Occurred()) SWIG_fail;
49199 }
49200 resultobj = SWIG_Py_Void();
49201 return resultobj;
49202 fail:
49203 return NULL;
49204 }
49205
49206
49207 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49208 PyObject *obj;
49209 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49210 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49211 return SWIG_Py_Void();
49212 }
49213
49214 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49215 return SWIG_Python_InitShadowInstance(args);
49216 }
49217
49218 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49219 PyObject *resultobj = 0;
49220 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49221 int arg2 = (int) wxHORIZONTAL ;
49222 wxStaticBoxSizer *result = 0 ;
49223 void *argp1 = 0 ;
49224 int res1 = 0 ;
49225 int val2 ;
49226 int ecode2 = 0 ;
49227 PyObject * obj0 = 0 ;
49228 PyObject * obj1 = 0 ;
49229 char * kwnames[] = {
49230 (char *) "box",(char *) "orient", NULL
49231 };
49232
49233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49235 if (!SWIG_IsOK(res1)) {
49236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49237 }
49238 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49239 if (obj1) {
49240 ecode2 = SWIG_AsVal_int(obj1, &val2);
49241 if (!SWIG_IsOK(ecode2)) {
49242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49243 }
49244 arg2 = static_cast< int >(val2);
49245 }
49246 {
49247 PyThreadState* __tstate = wxPyBeginAllowThreads();
49248 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49249 wxPyEndAllowThreads(__tstate);
49250 if (PyErr_Occurred()) SWIG_fail;
49251 }
49252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49253 return resultobj;
49254 fail:
49255 return NULL;
49256 }
49257
49258
49259 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49260 PyObject *resultobj = 0;
49261 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49262 wxStaticBox *result = 0 ;
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_wxStaticBoxSizer, 0 | 0 );
49270 if (!SWIG_IsOK(res1)) {
49271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49272 }
49273 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49274 {
49275 PyThreadState* __tstate = wxPyBeginAllowThreads();
49276 result = (wxStaticBox *)(arg1)->GetStaticBox();
49277 wxPyEndAllowThreads(__tstate);
49278 if (PyErr_Occurred()) SWIG_fail;
49279 }
49280 {
49281 resultobj = wxPyMake_wxObject(result, (bool)0);
49282 }
49283 return resultobj;
49284 fail:
49285 return NULL;
49286 }
49287
49288
49289 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49290 PyObject *obj;
49291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49292 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49293 return SWIG_Py_Void();
49294 }
49295
49296 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49297 return SWIG_Python_InitShadowInstance(args);
49298 }
49299
49300 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49301 PyObject *resultobj = 0;
49302 int arg1 = (int) 1 ;
49303 int arg2 = (int) 0 ;
49304 int arg3 = (int) 0 ;
49305 int arg4 = (int) 0 ;
49306 wxGridSizer *result = 0 ;
49307 int val1 ;
49308 int ecode1 = 0 ;
49309 int val2 ;
49310 int ecode2 = 0 ;
49311 int val3 ;
49312 int ecode3 = 0 ;
49313 int val4 ;
49314 int ecode4 = 0 ;
49315 PyObject * obj0 = 0 ;
49316 PyObject * obj1 = 0 ;
49317 PyObject * obj2 = 0 ;
49318 PyObject * obj3 = 0 ;
49319 char * kwnames[] = {
49320 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49321 };
49322
49323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49324 if (obj0) {
49325 ecode1 = SWIG_AsVal_int(obj0, &val1);
49326 if (!SWIG_IsOK(ecode1)) {
49327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49328 }
49329 arg1 = static_cast< int >(val1);
49330 }
49331 if (obj1) {
49332 ecode2 = SWIG_AsVal_int(obj1, &val2);
49333 if (!SWIG_IsOK(ecode2)) {
49334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49335 }
49336 arg2 = static_cast< int >(val2);
49337 }
49338 if (obj2) {
49339 ecode3 = SWIG_AsVal_int(obj2, &val3);
49340 if (!SWIG_IsOK(ecode3)) {
49341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49342 }
49343 arg3 = static_cast< int >(val3);
49344 }
49345 if (obj3) {
49346 ecode4 = SWIG_AsVal_int(obj3, &val4);
49347 if (!SWIG_IsOK(ecode4)) {
49348 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49349 }
49350 arg4 = static_cast< int >(val4);
49351 }
49352 {
49353 PyThreadState* __tstate = wxPyBeginAllowThreads();
49354 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49355 wxPyEndAllowThreads(__tstate);
49356 if (PyErr_Occurred()) SWIG_fail;
49357 }
49358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49359 return resultobj;
49360 fail:
49361 return NULL;
49362 }
49363
49364
49365 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49366 PyObject *resultobj = 0;
49367 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49368 int arg2 ;
49369 void *argp1 = 0 ;
49370 int res1 = 0 ;
49371 int val2 ;
49372 int ecode2 = 0 ;
49373 PyObject * obj0 = 0 ;
49374 PyObject * obj1 = 0 ;
49375 char * kwnames[] = {
49376 (char *) "self",(char *) "cols", NULL
49377 };
49378
49379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49381 if (!SWIG_IsOK(res1)) {
49382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49383 }
49384 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49385 ecode2 = SWIG_AsVal_int(obj1, &val2);
49386 if (!SWIG_IsOK(ecode2)) {
49387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49388 }
49389 arg2 = static_cast< int >(val2);
49390 {
49391 PyThreadState* __tstate = wxPyBeginAllowThreads();
49392 (arg1)->SetCols(arg2);
49393 wxPyEndAllowThreads(__tstate);
49394 if (PyErr_Occurred()) SWIG_fail;
49395 }
49396 resultobj = SWIG_Py_Void();
49397 return resultobj;
49398 fail:
49399 return NULL;
49400 }
49401
49402
49403 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49404 PyObject *resultobj = 0;
49405 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49406 int arg2 ;
49407 void *argp1 = 0 ;
49408 int res1 = 0 ;
49409 int val2 ;
49410 int ecode2 = 0 ;
49411 PyObject * obj0 = 0 ;
49412 PyObject * obj1 = 0 ;
49413 char * kwnames[] = {
49414 (char *) "self",(char *) "rows", NULL
49415 };
49416
49417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49419 if (!SWIG_IsOK(res1)) {
49420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49421 }
49422 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49423 ecode2 = SWIG_AsVal_int(obj1, &val2);
49424 if (!SWIG_IsOK(ecode2)) {
49425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49426 }
49427 arg2 = static_cast< int >(val2);
49428 {
49429 PyThreadState* __tstate = wxPyBeginAllowThreads();
49430 (arg1)->SetRows(arg2);
49431 wxPyEndAllowThreads(__tstate);
49432 if (PyErr_Occurred()) SWIG_fail;
49433 }
49434 resultobj = SWIG_Py_Void();
49435 return resultobj;
49436 fail:
49437 return NULL;
49438 }
49439
49440
49441 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49442 PyObject *resultobj = 0;
49443 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49444 int arg2 ;
49445 void *argp1 = 0 ;
49446 int res1 = 0 ;
49447 int val2 ;
49448 int ecode2 = 0 ;
49449 PyObject * obj0 = 0 ;
49450 PyObject * obj1 = 0 ;
49451 char * kwnames[] = {
49452 (char *) "self",(char *) "gap", NULL
49453 };
49454
49455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49457 if (!SWIG_IsOK(res1)) {
49458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49459 }
49460 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49461 ecode2 = SWIG_AsVal_int(obj1, &val2);
49462 if (!SWIG_IsOK(ecode2)) {
49463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49464 }
49465 arg2 = static_cast< int >(val2);
49466 {
49467 PyThreadState* __tstate = wxPyBeginAllowThreads();
49468 (arg1)->SetVGap(arg2);
49469 wxPyEndAllowThreads(__tstate);
49470 if (PyErr_Occurred()) SWIG_fail;
49471 }
49472 resultobj = SWIG_Py_Void();
49473 return resultobj;
49474 fail:
49475 return NULL;
49476 }
49477
49478
49479 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49480 PyObject *resultobj = 0;
49481 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49482 int arg2 ;
49483 void *argp1 = 0 ;
49484 int res1 = 0 ;
49485 int val2 ;
49486 int ecode2 = 0 ;
49487 PyObject * obj0 = 0 ;
49488 PyObject * obj1 = 0 ;
49489 char * kwnames[] = {
49490 (char *) "self",(char *) "gap", NULL
49491 };
49492
49493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49495 if (!SWIG_IsOK(res1)) {
49496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49497 }
49498 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49499 ecode2 = SWIG_AsVal_int(obj1, &val2);
49500 if (!SWIG_IsOK(ecode2)) {
49501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49502 }
49503 arg2 = static_cast< int >(val2);
49504 {
49505 PyThreadState* __tstate = wxPyBeginAllowThreads();
49506 (arg1)->SetHGap(arg2);
49507 wxPyEndAllowThreads(__tstate);
49508 if (PyErr_Occurred()) SWIG_fail;
49509 }
49510 resultobj = SWIG_Py_Void();
49511 return resultobj;
49512 fail:
49513 return NULL;
49514 }
49515
49516
49517 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49518 PyObject *resultobj = 0;
49519 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49520 int result;
49521 void *argp1 = 0 ;
49522 int res1 = 0 ;
49523 PyObject *swig_obj[1] ;
49524
49525 if (!args) SWIG_fail;
49526 swig_obj[0] = args;
49527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49528 if (!SWIG_IsOK(res1)) {
49529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49530 }
49531 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49532 {
49533 PyThreadState* __tstate = wxPyBeginAllowThreads();
49534 result = (int)(arg1)->GetCols();
49535 wxPyEndAllowThreads(__tstate);
49536 if (PyErr_Occurred()) SWIG_fail;
49537 }
49538 resultobj = SWIG_From_int(static_cast< int >(result));
49539 return resultobj;
49540 fail:
49541 return NULL;
49542 }
49543
49544
49545 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49546 PyObject *resultobj = 0;
49547 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49548 int result;
49549 void *argp1 = 0 ;
49550 int res1 = 0 ;
49551 PyObject *swig_obj[1] ;
49552
49553 if (!args) SWIG_fail;
49554 swig_obj[0] = args;
49555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49556 if (!SWIG_IsOK(res1)) {
49557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49558 }
49559 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49560 {
49561 PyThreadState* __tstate = wxPyBeginAllowThreads();
49562 result = (int)(arg1)->GetRows();
49563 wxPyEndAllowThreads(__tstate);
49564 if (PyErr_Occurred()) SWIG_fail;
49565 }
49566 resultobj = SWIG_From_int(static_cast< int >(result));
49567 return resultobj;
49568 fail:
49569 return NULL;
49570 }
49571
49572
49573 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49574 PyObject *resultobj = 0;
49575 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49576 int result;
49577 void *argp1 = 0 ;
49578 int res1 = 0 ;
49579 PyObject *swig_obj[1] ;
49580
49581 if (!args) SWIG_fail;
49582 swig_obj[0] = args;
49583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49584 if (!SWIG_IsOK(res1)) {
49585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49586 }
49587 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49588 {
49589 PyThreadState* __tstate = wxPyBeginAllowThreads();
49590 result = (int)(arg1)->GetVGap();
49591 wxPyEndAllowThreads(__tstate);
49592 if (PyErr_Occurred()) SWIG_fail;
49593 }
49594 resultobj = SWIG_From_int(static_cast< int >(result));
49595 return resultobj;
49596 fail:
49597 return NULL;
49598 }
49599
49600
49601 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49602 PyObject *resultobj = 0;
49603 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49604 int result;
49605 void *argp1 = 0 ;
49606 int res1 = 0 ;
49607 PyObject *swig_obj[1] ;
49608
49609 if (!args) SWIG_fail;
49610 swig_obj[0] = args;
49611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49612 if (!SWIG_IsOK(res1)) {
49613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49614 }
49615 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49616 {
49617 PyThreadState* __tstate = wxPyBeginAllowThreads();
49618 result = (int)(arg1)->GetHGap();
49619 wxPyEndAllowThreads(__tstate);
49620 if (PyErr_Occurred()) SWIG_fail;
49621 }
49622 resultobj = SWIG_From_int(static_cast< int >(result));
49623 return resultobj;
49624 fail:
49625 return NULL;
49626 }
49627
49628
49629 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49630 PyObject *obj;
49631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49632 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49633 return SWIG_Py_Void();
49634 }
49635
49636 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49637 return SWIG_Python_InitShadowInstance(args);
49638 }
49639
49640 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49641 PyObject *resultobj = 0;
49642 int arg1 = (int) 1 ;
49643 int arg2 = (int) 0 ;
49644 int arg3 = (int) 0 ;
49645 int arg4 = (int) 0 ;
49646 wxFlexGridSizer *result = 0 ;
49647 int val1 ;
49648 int ecode1 = 0 ;
49649 int val2 ;
49650 int ecode2 = 0 ;
49651 int val3 ;
49652 int ecode3 = 0 ;
49653 int val4 ;
49654 int ecode4 = 0 ;
49655 PyObject * obj0 = 0 ;
49656 PyObject * obj1 = 0 ;
49657 PyObject * obj2 = 0 ;
49658 PyObject * obj3 = 0 ;
49659 char * kwnames[] = {
49660 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49661 };
49662
49663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49664 if (obj0) {
49665 ecode1 = SWIG_AsVal_int(obj0, &val1);
49666 if (!SWIG_IsOK(ecode1)) {
49667 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49668 }
49669 arg1 = static_cast< int >(val1);
49670 }
49671 if (obj1) {
49672 ecode2 = SWIG_AsVal_int(obj1, &val2);
49673 if (!SWIG_IsOK(ecode2)) {
49674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49675 }
49676 arg2 = static_cast< int >(val2);
49677 }
49678 if (obj2) {
49679 ecode3 = SWIG_AsVal_int(obj2, &val3);
49680 if (!SWIG_IsOK(ecode3)) {
49681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49682 }
49683 arg3 = static_cast< int >(val3);
49684 }
49685 if (obj3) {
49686 ecode4 = SWIG_AsVal_int(obj3, &val4);
49687 if (!SWIG_IsOK(ecode4)) {
49688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49689 }
49690 arg4 = static_cast< int >(val4);
49691 }
49692 {
49693 PyThreadState* __tstate = wxPyBeginAllowThreads();
49694 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49695 wxPyEndAllowThreads(__tstate);
49696 if (PyErr_Occurred()) SWIG_fail;
49697 }
49698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49699 return resultobj;
49700 fail:
49701 return NULL;
49702 }
49703
49704
49705 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49706 PyObject *resultobj = 0;
49707 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49708 size_t arg2 ;
49709 int arg3 = (int) 0 ;
49710 void *argp1 = 0 ;
49711 int res1 = 0 ;
49712 size_t val2 ;
49713 int ecode2 = 0 ;
49714 int val3 ;
49715 int ecode3 = 0 ;
49716 PyObject * obj0 = 0 ;
49717 PyObject * obj1 = 0 ;
49718 PyObject * obj2 = 0 ;
49719 char * kwnames[] = {
49720 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49721 };
49722
49723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49725 if (!SWIG_IsOK(res1)) {
49726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49727 }
49728 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49729 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49730 if (!SWIG_IsOK(ecode2)) {
49731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49732 }
49733 arg2 = static_cast< size_t >(val2);
49734 if (obj2) {
49735 ecode3 = SWIG_AsVal_int(obj2, &val3);
49736 if (!SWIG_IsOK(ecode3)) {
49737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49738 }
49739 arg3 = static_cast< int >(val3);
49740 }
49741 {
49742 PyThreadState* __tstate = wxPyBeginAllowThreads();
49743 (arg1)->AddGrowableRow(arg2,arg3);
49744 wxPyEndAllowThreads(__tstate);
49745 if (PyErr_Occurred()) SWIG_fail;
49746 }
49747 resultobj = SWIG_Py_Void();
49748 return resultobj;
49749 fail:
49750 return NULL;
49751 }
49752
49753
49754 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49755 PyObject *resultobj = 0;
49756 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49757 size_t arg2 ;
49758 void *argp1 = 0 ;
49759 int res1 = 0 ;
49760 size_t val2 ;
49761 int ecode2 = 0 ;
49762 PyObject * obj0 = 0 ;
49763 PyObject * obj1 = 0 ;
49764 char * kwnames[] = {
49765 (char *) "self",(char *) "idx", NULL
49766 };
49767
49768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49770 if (!SWIG_IsOK(res1)) {
49771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49772 }
49773 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49774 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49775 if (!SWIG_IsOK(ecode2)) {
49776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49777 }
49778 arg2 = static_cast< size_t >(val2);
49779 {
49780 PyThreadState* __tstate = wxPyBeginAllowThreads();
49781 (arg1)->RemoveGrowableRow(arg2);
49782 wxPyEndAllowThreads(__tstate);
49783 if (PyErr_Occurred()) SWIG_fail;
49784 }
49785 resultobj = SWIG_Py_Void();
49786 return resultobj;
49787 fail:
49788 return NULL;
49789 }
49790
49791
49792 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49793 PyObject *resultobj = 0;
49794 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49795 size_t arg2 ;
49796 int arg3 = (int) 0 ;
49797 void *argp1 = 0 ;
49798 int res1 = 0 ;
49799 size_t val2 ;
49800 int ecode2 = 0 ;
49801 int val3 ;
49802 int ecode3 = 0 ;
49803 PyObject * obj0 = 0 ;
49804 PyObject * obj1 = 0 ;
49805 PyObject * obj2 = 0 ;
49806 char * kwnames[] = {
49807 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49808 };
49809
49810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49812 if (!SWIG_IsOK(res1)) {
49813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49814 }
49815 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49816 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49817 if (!SWIG_IsOK(ecode2)) {
49818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49819 }
49820 arg2 = static_cast< size_t >(val2);
49821 if (obj2) {
49822 ecode3 = SWIG_AsVal_int(obj2, &val3);
49823 if (!SWIG_IsOK(ecode3)) {
49824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49825 }
49826 arg3 = static_cast< int >(val3);
49827 }
49828 {
49829 PyThreadState* __tstate = wxPyBeginAllowThreads();
49830 (arg1)->AddGrowableCol(arg2,arg3);
49831 wxPyEndAllowThreads(__tstate);
49832 if (PyErr_Occurred()) SWIG_fail;
49833 }
49834 resultobj = SWIG_Py_Void();
49835 return resultobj;
49836 fail:
49837 return NULL;
49838 }
49839
49840
49841 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49842 PyObject *resultobj = 0;
49843 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49844 size_t arg2 ;
49845 void *argp1 = 0 ;
49846 int res1 = 0 ;
49847 size_t val2 ;
49848 int ecode2 = 0 ;
49849 PyObject * obj0 = 0 ;
49850 PyObject * obj1 = 0 ;
49851 char * kwnames[] = {
49852 (char *) "self",(char *) "idx", NULL
49853 };
49854
49855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49857 if (!SWIG_IsOK(res1)) {
49858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49859 }
49860 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49861 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49862 if (!SWIG_IsOK(ecode2)) {
49863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49864 }
49865 arg2 = static_cast< size_t >(val2);
49866 {
49867 PyThreadState* __tstate = wxPyBeginAllowThreads();
49868 (arg1)->RemoveGrowableCol(arg2);
49869 wxPyEndAllowThreads(__tstate);
49870 if (PyErr_Occurred()) SWIG_fail;
49871 }
49872 resultobj = SWIG_Py_Void();
49873 return resultobj;
49874 fail:
49875 return NULL;
49876 }
49877
49878
49879 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49880 PyObject *resultobj = 0;
49881 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49882 int arg2 ;
49883 void *argp1 = 0 ;
49884 int res1 = 0 ;
49885 int val2 ;
49886 int ecode2 = 0 ;
49887 PyObject * obj0 = 0 ;
49888 PyObject * obj1 = 0 ;
49889 char * kwnames[] = {
49890 (char *) "self",(char *) "direction", NULL
49891 };
49892
49893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49895 if (!SWIG_IsOK(res1)) {
49896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49897 }
49898 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49899 ecode2 = SWIG_AsVal_int(obj1, &val2);
49900 if (!SWIG_IsOK(ecode2)) {
49901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49902 }
49903 arg2 = static_cast< int >(val2);
49904 {
49905 PyThreadState* __tstate = wxPyBeginAllowThreads();
49906 (arg1)->SetFlexibleDirection(arg2);
49907 wxPyEndAllowThreads(__tstate);
49908 if (PyErr_Occurred()) SWIG_fail;
49909 }
49910 resultobj = SWIG_Py_Void();
49911 return resultobj;
49912 fail:
49913 return NULL;
49914 }
49915
49916
49917 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49918 PyObject *resultobj = 0;
49919 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49920 int result;
49921 void *argp1 = 0 ;
49922 int res1 = 0 ;
49923 PyObject *swig_obj[1] ;
49924
49925 if (!args) SWIG_fail;
49926 swig_obj[0] = args;
49927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49928 if (!SWIG_IsOK(res1)) {
49929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49930 }
49931 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49932 {
49933 PyThreadState* __tstate = wxPyBeginAllowThreads();
49934 result = (int)(arg1)->GetFlexibleDirection();
49935 wxPyEndAllowThreads(__tstate);
49936 if (PyErr_Occurred()) SWIG_fail;
49937 }
49938 resultobj = SWIG_From_int(static_cast< int >(result));
49939 return resultobj;
49940 fail:
49941 return NULL;
49942 }
49943
49944
49945 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49946 PyObject *resultobj = 0;
49947 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49948 wxFlexSizerGrowMode arg2 ;
49949 void *argp1 = 0 ;
49950 int res1 = 0 ;
49951 int val2 ;
49952 int ecode2 = 0 ;
49953 PyObject * obj0 = 0 ;
49954 PyObject * obj1 = 0 ;
49955 char * kwnames[] = {
49956 (char *) "self",(char *) "mode", NULL
49957 };
49958
49959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49961 if (!SWIG_IsOK(res1)) {
49962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49963 }
49964 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49965 ecode2 = SWIG_AsVal_int(obj1, &val2);
49966 if (!SWIG_IsOK(ecode2)) {
49967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49968 }
49969 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49970 {
49971 PyThreadState* __tstate = wxPyBeginAllowThreads();
49972 (arg1)->SetNonFlexibleGrowMode(arg2);
49973 wxPyEndAllowThreads(__tstate);
49974 if (PyErr_Occurred()) SWIG_fail;
49975 }
49976 resultobj = SWIG_Py_Void();
49977 return resultobj;
49978 fail:
49979 return NULL;
49980 }
49981
49982
49983 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49984 PyObject *resultobj = 0;
49985 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49986 wxFlexSizerGrowMode result;
49987 void *argp1 = 0 ;
49988 int res1 = 0 ;
49989 PyObject *swig_obj[1] ;
49990
49991 if (!args) SWIG_fail;
49992 swig_obj[0] = args;
49993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49994 if (!SWIG_IsOK(res1)) {
49995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49996 }
49997 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49998 {
49999 PyThreadState* __tstate = wxPyBeginAllowThreads();
50000 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
50001 wxPyEndAllowThreads(__tstate);
50002 if (PyErr_Occurred()) SWIG_fail;
50003 }
50004 resultobj = SWIG_From_int(static_cast< int >(result));
50005 return resultobj;
50006 fail:
50007 return NULL;
50008 }
50009
50010
50011 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50012 PyObject *resultobj = 0;
50013 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50014 wxArrayInt *result = 0 ;
50015 void *argp1 = 0 ;
50016 int res1 = 0 ;
50017 PyObject *swig_obj[1] ;
50018
50019 if (!args) SWIG_fail;
50020 swig_obj[0] = args;
50021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50022 if (!SWIG_IsOK(res1)) {
50023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50024 }
50025 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50026 {
50027 PyThreadState* __tstate = wxPyBeginAllowThreads();
50028 {
50029 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
50030 result = (wxArrayInt *) &_result_ref;
50031 }
50032 wxPyEndAllowThreads(__tstate);
50033 if (PyErr_Occurred()) SWIG_fail;
50034 }
50035 {
50036 resultobj = wxArrayInt2PyList_helper(*result);
50037 }
50038 return resultobj;
50039 fail:
50040 return NULL;
50041 }
50042
50043
50044 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50045 PyObject *resultobj = 0;
50046 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50047 wxArrayInt *result = 0 ;
50048 void *argp1 = 0 ;
50049 int res1 = 0 ;
50050 PyObject *swig_obj[1] ;
50051
50052 if (!args) SWIG_fail;
50053 swig_obj[0] = args;
50054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50055 if (!SWIG_IsOK(res1)) {
50056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50057 }
50058 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50059 {
50060 PyThreadState* __tstate = wxPyBeginAllowThreads();
50061 {
50062 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
50063 result = (wxArrayInt *) &_result_ref;
50064 }
50065 wxPyEndAllowThreads(__tstate);
50066 if (PyErr_Occurred()) SWIG_fail;
50067 }
50068 {
50069 resultobj = wxArrayInt2PyList_helper(*result);
50070 }
50071 return resultobj;
50072 fail:
50073 return NULL;
50074 }
50075
50076
50077 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50078 PyObject *obj;
50079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50080 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
50081 return SWIG_Py_Void();
50082 }
50083
50084 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50085 return SWIG_Python_InitShadowInstance(args);
50086 }
50087
50088 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50089 PyObject *resultobj = 0;
50090 wxStdDialogButtonSizer *result = 0 ;
50091
50092 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
50093 {
50094 PyThreadState* __tstate = wxPyBeginAllowThreads();
50095 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
50096 wxPyEndAllowThreads(__tstate);
50097 if (PyErr_Occurred()) SWIG_fail;
50098 }
50099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
50100 return resultobj;
50101 fail:
50102 return NULL;
50103 }
50104
50105
50106 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50107 PyObject *resultobj = 0;
50108 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50109 wxButton *arg2 = (wxButton *) 0 ;
50110 void *argp1 = 0 ;
50111 int res1 = 0 ;
50112 void *argp2 = 0 ;
50113 int res2 = 0 ;
50114 PyObject * obj0 = 0 ;
50115 PyObject * obj1 = 0 ;
50116 char * kwnames[] = {
50117 (char *) "self",(char *) "button", NULL
50118 };
50119
50120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
50121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50122 if (!SWIG_IsOK(res1)) {
50123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50124 }
50125 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50127 if (!SWIG_IsOK(res2)) {
50128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
50129 }
50130 arg2 = reinterpret_cast< wxButton * >(argp2);
50131 {
50132 PyThreadState* __tstate = wxPyBeginAllowThreads();
50133 (arg1)->AddButton(arg2);
50134 wxPyEndAllowThreads(__tstate);
50135 if (PyErr_Occurred()) SWIG_fail;
50136 }
50137 resultobj = SWIG_Py_Void();
50138 return resultobj;
50139 fail:
50140 return NULL;
50141 }
50142
50143
50144 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50145 PyObject *resultobj = 0;
50146 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50147 void *argp1 = 0 ;
50148 int res1 = 0 ;
50149 PyObject *swig_obj[1] ;
50150
50151 if (!args) SWIG_fail;
50152 swig_obj[0] = args;
50153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50154 if (!SWIG_IsOK(res1)) {
50155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50156 }
50157 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50158 {
50159 PyThreadState* __tstate = wxPyBeginAllowThreads();
50160 (arg1)->Realize();
50161 wxPyEndAllowThreads(__tstate);
50162 if (PyErr_Occurred()) SWIG_fail;
50163 }
50164 resultobj = SWIG_Py_Void();
50165 return resultobj;
50166 fail:
50167 return NULL;
50168 }
50169
50170
50171 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50172 PyObject *resultobj = 0;
50173 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50174 wxButton *arg2 = (wxButton *) 0 ;
50175 void *argp1 = 0 ;
50176 int res1 = 0 ;
50177 void *argp2 = 0 ;
50178 int res2 = 0 ;
50179 PyObject * obj0 = 0 ;
50180 PyObject * obj1 = 0 ;
50181 char * kwnames[] = {
50182 (char *) "self",(char *) "button", NULL
50183 };
50184
50185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50187 if (!SWIG_IsOK(res1)) {
50188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50189 }
50190 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50192 if (!SWIG_IsOK(res2)) {
50193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50194 }
50195 arg2 = reinterpret_cast< wxButton * >(argp2);
50196 {
50197 PyThreadState* __tstate = wxPyBeginAllowThreads();
50198 (arg1)->SetAffirmativeButton(arg2);
50199 wxPyEndAllowThreads(__tstate);
50200 if (PyErr_Occurred()) SWIG_fail;
50201 }
50202 resultobj = SWIG_Py_Void();
50203 return resultobj;
50204 fail:
50205 return NULL;
50206 }
50207
50208
50209 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50210 PyObject *resultobj = 0;
50211 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50212 wxButton *arg2 = (wxButton *) 0 ;
50213 void *argp1 = 0 ;
50214 int res1 = 0 ;
50215 void *argp2 = 0 ;
50216 int res2 = 0 ;
50217 PyObject * obj0 = 0 ;
50218 PyObject * obj1 = 0 ;
50219 char * kwnames[] = {
50220 (char *) "self",(char *) "button", NULL
50221 };
50222
50223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50225 if (!SWIG_IsOK(res1)) {
50226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50227 }
50228 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50230 if (!SWIG_IsOK(res2)) {
50231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50232 }
50233 arg2 = reinterpret_cast< wxButton * >(argp2);
50234 {
50235 PyThreadState* __tstate = wxPyBeginAllowThreads();
50236 (arg1)->SetNegativeButton(arg2);
50237 wxPyEndAllowThreads(__tstate);
50238 if (PyErr_Occurred()) SWIG_fail;
50239 }
50240 resultobj = SWIG_Py_Void();
50241 return resultobj;
50242 fail:
50243 return NULL;
50244 }
50245
50246
50247 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50248 PyObject *resultobj = 0;
50249 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50250 wxButton *arg2 = (wxButton *) 0 ;
50251 void *argp1 = 0 ;
50252 int res1 = 0 ;
50253 void *argp2 = 0 ;
50254 int res2 = 0 ;
50255 PyObject * obj0 = 0 ;
50256 PyObject * obj1 = 0 ;
50257 char * kwnames[] = {
50258 (char *) "self",(char *) "button", NULL
50259 };
50260
50261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50263 if (!SWIG_IsOK(res1)) {
50264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50265 }
50266 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50268 if (!SWIG_IsOK(res2)) {
50269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50270 }
50271 arg2 = reinterpret_cast< wxButton * >(argp2);
50272 {
50273 PyThreadState* __tstate = wxPyBeginAllowThreads();
50274 (arg1)->SetCancelButton(arg2);
50275 wxPyEndAllowThreads(__tstate);
50276 if (PyErr_Occurred()) SWIG_fail;
50277 }
50278 resultobj = SWIG_Py_Void();
50279 return resultobj;
50280 fail:
50281 return NULL;
50282 }
50283
50284
50285 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50286 PyObject *resultobj = 0;
50287 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50288 wxButton *result = 0 ;
50289 void *argp1 = 0 ;
50290 int res1 = 0 ;
50291 PyObject *swig_obj[1] ;
50292
50293 if (!args) SWIG_fail;
50294 swig_obj[0] = args;
50295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50296 if (!SWIG_IsOK(res1)) {
50297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50298 }
50299 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50300 {
50301 PyThreadState* __tstate = wxPyBeginAllowThreads();
50302 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50303 wxPyEndAllowThreads(__tstate);
50304 if (PyErr_Occurred()) SWIG_fail;
50305 }
50306 {
50307 resultobj = wxPyMake_wxObject(result, (bool)0);
50308 }
50309 return resultobj;
50310 fail:
50311 return NULL;
50312 }
50313
50314
50315 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50316 PyObject *resultobj = 0;
50317 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50318 wxButton *result = 0 ;
50319 void *argp1 = 0 ;
50320 int res1 = 0 ;
50321 PyObject *swig_obj[1] ;
50322
50323 if (!args) SWIG_fail;
50324 swig_obj[0] = args;
50325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50326 if (!SWIG_IsOK(res1)) {
50327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50328 }
50329 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50330 {
50331 PyThreadState* __tstate = wxPyBeginAllowThreads();
50332 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50333 wxPyEndAllowThreads(__tstate);
50334 if (PyErr_Occurred()) SWIG_fail;
50335 }
50336 {
50337 resultobj = wxPyMake_wxObject(result, (bool)0);
50338 }
50339 return resultobj;
50340 fail:
50341 return NULL;
50342 }
50343
50344
50345 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50346 PyObject *resultobj = 0;
50347 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50348 wxButton *result = 0 ;
50349 void *argp1 = 0 ;
50350 int res1 = 0 ;
50351 PyObject *swig_obj[1] ;
50352
50353 if (!args) SWIG_fail;
50354 swig_obj[0] = args;
50355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50356 if (!SWIG_IsOK(res1)) {
50357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50358 }
50359 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50360 {
50361 PyThreadState* __tstate = wxPyBeginAllowThreads();
50362 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50363 wxPyEndAllowThreads(__tstate);
50364 if (PyErr_Occurred()) SWIG_fail;
50365 }
50366 {
50367 resultobj = wxPyMake_wxObject(result, (bool)0);
50368 }
50369 return resultobj;
50370 fail:
50371 return NULL;
50372 }
50373
50374
50375 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50376 PyObject *resultobj = 0;
50377 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50378 wxButton *result = 0 ;
50379 void *argp1 = 0 ;
50380 int res1 = 0 ;
50381 PyObject *swig_obj[1] ;
50382
50383 if (!args) SWIG_fail;
50384 swig_obj[0] = args;
50385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50386 if (!SWIG_IsOK(res1)) {
50387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50388 }
50389 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50390 {
50391 PyThreadState* __tstate = wxPyBeginAllowThreads();
50392 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50393 wxPyEndAllowThreads(__tstate);
50394 if (PyErr_Occurred()) SWIG_fail;
50395 }
50396 {
50397 resultobj = wxPyMake_wxObject(result, (bool)0);
50398 }
50399 return resultobj;
50400 fail:
50401 return NULL;
50402 }
50403
50404
50405 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50406 PyObject *resultobj = 0;
50407 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50408 wxButton *result = 0 ;
50409 void *argp1 = 0 ;
50410 int res1 = 0 ;
50411 PyObject *swig_obj[1] ;
50412
50413 if (!args) SWIG_fail;
50414 swig_obj[0] = args;
50415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50416 if (!SWIG_IsOK(res1)) {
50417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50418 }
50419 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50420 {
50421 PyThreadState* __tstate = wxPyBeginAllowThreads();
50422 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50423 wxPyEndAllowThreads(__tstate);
50424 if (PyErr_Occurred()) SWIG_fail;
50425 }
50426 {
50427 resultobj = wxPyMake_wxObject(result, (bool)0);
50428 }
50429 return resultobj;
50430 fail:
50431 return NULL;
50432 }
50433
50434
50435 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50436 PyObject *obj;
50437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50438 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50439 return SWIG_Py_Void();
50440 }
50441
50442 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50443 return SWIG_Python_InitShadowInstance(args);
50444 }
50445
50446 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50447 PyObject *resultobj = 0;
50448 int arg1 = (int) 0 ;
50449 int arg2 = (int) 0 ;
50450 wxGBPosition *result = 0 ;
50451 int val1 ;
50452 int ecode1 = 0 ;
50453 int val2 ;
50454 int ecode2 = 0 ;
50455 PyObject * obj0 = 0 ;
50456 PyObject * obj1 = 0 ;
50457 char * kwnames[] = {
50458 (char *) "row",(char *) "col", NULL
50459 };
50460
50461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50462 if (obj0) {
50463 ecode1 = SWIG_AsVal_int(obj0, &val1);
50464 if (!SWIG_IsOK(ecode1)) {
50465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50466 }
50467 arg1 = static_cast< int >(val1);
50468 }
50469 if (obj1) {
50470 ecode2 = SWIG_AsVal_int(obj1, &val2);
50471 if (!SWIG_IsOK(ecode2)) {
50472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50473 }
50474 arg2 = static_cast< int >(val2);
50475 }
50476 {
50477 PyThreadState* __tstate = wxPyBeginAllowThreads();
50478 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50479 wxPyEndAllowThreads(__tstate);
50480 if (PyErr_Occurred()) SWIG_fail;
50481 }
50482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50483 return resultobj;
50484 fail:
50485 return NULL;
50486 }
50487
50488
50489 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50490 PyObject *resultobj = 0;
50491 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50492 void *argp1 = 0 ;
50493 int res1 = 0 ;
50494 PyObject *swig_obj[1] ;
50495
50496 if (!args) SWIG_fail;
50497 swig_obj[0] = args;
50498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50499 if (!SWIG_IsOK(res1)) {
50500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50501 }
50502 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50503 {
50504 PyThreadState* __tstate = wxPyBeginAllowThreads();
50505 delete arg1;
50506
50507 wxPyEndAllowThreads(__tstate);
50508 if (PyErr_Occurred()) SWIG_fail;
50509 }
50510 resultobj = SWIG_Py_Void();
50511 return resultobj;
50512 fail:
50513 return NULL;
50514 }
50515
50516
50517 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50518 PyObject *resultobj = 0;
50519 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50520 int result;
50521 void *argp1 = 0 ;
50522 int res1 = 0 ;
50523 PyObject *swig_obj[1] ;
50524
50525 if (!args) SWIG_fail;
50526 swig_obj[0] = args;
50527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50528 if (!SWIG_IsOK(res1)) {
50529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50530 }
50531 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50532 {
50533 PyThreadState* __tstate = wxPyBeginAllowThreads();
50534 result = (int)((wxGBPosition const *)arg1)->GetRow();
50535 wxPyEndAllowThreads(__tstate);
50536 if (PyErr_Occurred()) SWIG_fail;
50537 }
50538 resultobj = SWIG_From_int(static_cast< int >(result));
50539 return resultobj;
50540 fail:
50541 return NULL;
50542 }
50543
50544
50545 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50546 PyObject *resultobj = 0;
50547 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50548 int result;
50549 void *argp1 = 0 ;
50550 int res1 = 0 ;
50551 PyObject *swig_obj[1] ;
50552
50553 if (!args) SWIG_fail;
50554 swig_obj[0] = args;
50555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50556 if (!SWIG_IsOK(res1)) {
50557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50558 }
50559 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50560 {
50561 PyThreadState* __tstate = wxPyBeginAllowThreads();
50562 result = (int)((wxGBPosition const *)arg1)->GetCol();
50563 wxPyEndAllowThreads(__tstate);
50564 if (PyErr_Occurred()) SWIG_fail;
50565 }
50566 resultobj = SWIG_From_int(static_cast< int >(result));
50567 return resultobj;
50568 fail:
50569 return NULL;
50570 }
50571
50572
50573 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50574 PyObject *resultobj = 0;
50575 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50576 int arg2 ;
50577 void *argp1 = 0 ;
50578 int res1 = 0 ;
50579 int val2 ;
50580 int ecode2 = 0 ;
50581 PyObject * obj0 = 0 ;
50582 PyObject * obj1 = 0 ;
50583 char * kwnames[] = {
50584 (char *) "self",(char *) "row", NULL
50585 };
50586
50587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50589 if (!SWIG_IsOK(res1)) {
50590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50591 }
50592 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50593 ecode2 = SWIG_AsVal_int(obj1, &val2);
50594 if (!SWIG_IsOK(ecode2)) {
50595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50596 }
50597 arg2 = static_cast< int >(val2);
50598 {
50599 PyThreadState* __tstate = wxPyBeginAllowThreads();
50600 (arg1)->SetRow(arg2);
50601 wxPyEndAllowThreads(__tstate);
50602 if (PyErr_Occurred()) SWIG_fail;
50603 }
50604 resultobj = SWIG_Py_Void();
50605 return resultobj;
50606 fail:
50607 return NULL;
50608 }
50609
50610
50611 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50612 PyObject *resultobj = 0;
50613 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50614 int arg2 ;
50615 void *argp1 = 0 ;
50616 int res1 = 0 ;
50617 int val2 ;
50618 int ecode2 = 0 ;
50619 PyObject * obj0 = 0 ;
50620 PyObject * obj1 = 0 ;
50621 char * kwnames[] = {
50622 (char *) "self",(char *) "col", NULL
50623 };
50624
50625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50627 if (!SWIG_IsOK(res1)) {
50628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50629 }
50630 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50631 ecode2 = SWIG_AsVal_int(obj1, &val2);
50632 if (!SWIG_IsOK(ecode2)) {
50633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50634 }
50635 arg2 = static_cast< int >(val2);
50636 {
50637 PyThreadState* __tstate = wxPyBeginAllowThreads();
50638 (arg1)->SetCol(arg2);
50639 wxPyEndAllowThreads(__tstate);
50640 if (PyErr_Occurred()) SWIG_fail;
50641 }
50642 resultobj = SWIG_Py_Void();
50643 return resultobj;
50644 fail:
50645 return NULL;
50646 }
50647
50648
50649 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50650 PyObject *resultobj = 0;
50651 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50652 PyObject *arg2 = (PyObject *) 0 ;
50653 bool result;
50654 void *argp1 = 0 ;
50655 int res1 = 0 ;
50656 PyObject * obj0 = 0 ;
50657 PyObject * obj1 = 0 ;
50658 char * kwnames[] = {
50659 (char *) "self",(char *) "other", NULL
50660 };
50661
50662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50664 if (!SWIG_IsOK(res1)) {
50665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50666 }
50667 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50668 arg2 = obj1;
50669 {
50670 result = (bool)wxGBPosition___eq__(arg1,arg2);
50671 if (PyErr_Occurred()) SWIG_fail;
50672 }
50673 {
50674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50675 }
50676 return resultobj;
50677 fail:
50678 return NULL;
50679 }
50680
50681
50682 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50683 PyObject *resultobj = 0;
50684 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50685 PyObject *arg2 = (PyObject *) 0 ;
50686 bool result;
50687 void *argp1 = 0 ;
50688 int res1 = 0 ;
50689 PyObject * obj0 = 0 ;
50690 PyObject * obj1 = 0 ;
50691 char * kwnames[] = {
50692 (char *) "self",(char *) "other", NULL
50693 };
50694
50695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50697 if (!SWIG_IsOK(res1)) {
50698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50699 }
50700 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50701 arg2 = obj1;
50702 {
50703 result = (bool)wxGBPosition___ne__(arg1,arg2);
50704 if (PyErr_Occurred()) SWIG_fail;
50705 }
50706 {
50707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50708 }
50709 return resultobj;
50710 fail:
50711 return NULL;
50712 }
50713
50714
50715 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50716 PyObject *resultobj = 0;
50717 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50718 int arg2 = (int) 0 ;
50719 int arg3 = (int) 0 ;
50720 void *argp1 = 0 ;
50721 int res1 = 0 ;
50722 int val2 ;
50723 int ecode2 = 0 ;
50724 int val3 ;
50725 int ecode3 = 0 ;
50726 PyObject * obj0 = 0 ;
50727 PyObject * obj1 = 0 ;
50728 PyObject * obj2 = 0 ;
50729 char * kwnames[] = {
50730 (char *) "self",(char *) "row",(char *) "col", NULL
50731 };
50732
50733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50735 if (!SWIG_IsOK(res1)) {
50736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50737 }
50738 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50739 if (obj1) {
50740 ecode2 = SWIG_AsVal_int(obj1, &val2);
50741 if (!SWIG_IsOK(ecode2)) {
50742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50743 }
50744 arg2 = static_cast< int >(val2);
50745 }
50746 if (obj2) {
50747 ecode3 = SWIG_AsVal_int(obj2, &val3);
50748 if (!SWIG_IsOK(ecode3)) {
50749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50750 }
50751 arg3 = static_cast< int >(val3);
50752 }
50753 {
50754 PyThreadState* __tstate = wxPyBeginAllowThreads();
50755 wxGBPosition_Set(arg1,arg2,arg3);
50756 wxPyEndAllowThreads(__tstate);
50757 if (PyErr_Occurred()) SWIG_fail;
50758 }
50759 resultobj = SWIG_Py_Void();
50760 return resultobj;
50761 fail:
50762 return NULL;
50763 }
50764
50765
50766 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50767 PyObject *resultobj = 0;
50768 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50769 PyObject *result = 0 ;
50770 void *argp1 = 0 ;
50771 int res1 = 0 ;
50772 PyObject *swig_obj[1] ;
50773
50774 if (!args) SWIG_fail;
50775 swig_obj[0] = args;
50776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50777 if (!SWIG_IsOK(res1)) {
50778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50779 }
50780 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50781 {
50782 PyThreadState* __tstate = wxPyBeginAllowThreads();
50783 result = (PyObject *)wxGBPosition_Get(arg1);
50784 wxPyEndAllowThreads(__tstate);
50785 if (PyErr_Occurred()) SWIG_fail;
50786 }
50787 resultobj = result;
50788 return resultobj;
50789 fail:
50790 return NULL;
50791 }
50792
50793
50794 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50795 PyObject *obj;
50796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50797 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50798 return SWIG_Py_Void();
50799 }
50800
50801 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50802 return SWIG_Python_InitShadowInstance(args);
50803 }
50804
50805 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50806 PyObject *resultobj = 0;
50807 int arg1 = (int) 1 ;
50808 int arg2 = (int) 1 ;
50809 wxGBSpan *result = 0 ;
50810 int val1 ;
50811 int ecode1 = 0 ;
50812 int val2 ;
50813 int ecode2 = 0 ;
50814 PyObject * obj0 = 0 ;
50815 PyObject * obj1 = 0 ;
50816 char * kwnames[] = {
50817 (char *) "rowspan",(char *) "colspan", NULL
50818 };
50819
50820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50821 if (obj0) {
50822 ecode1 = SWIG_AsVal_int(obj0, &val1);
50823 if (!SWIG_IsOK(ecode1)) {
50824 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50825 }
50826 arg1 = static_cast< int >(val1);
50827 }
50828 if (obj1) {
50829 ecode2 = SWIG_AsVal_int(obj1, &val2);
50830 if (!SWIG_IsOK(ecode2)) {
50831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50832 }
50833 arg2 = static_cast< int >(val2);
50834 }
50835 {
50836 PyThreadState* __tstate = wxPyBeginAllowThreads();
50837 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50838 wxPyEndAllowThreads(__tstate);
50839 if (PyErr_Occurred()) SWIG_fail;
50840 }
50841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50842 return resultobj;
50843 fail:
50844 return NULL;
50845 }
50846
50847
50848 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50849 PyObject *resultobj = 0;
50850 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50851 void *argp1 = 0 ;
50852 int res1 = 0 ;
50853 PyObject *swig_obj[1] ;
50854
50855 if (!args) SWIG_fail;
50856 swig_obj[0] = args;
50857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50858 if (!SWIG_IsOK(res1)) {
50859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50860 }
50861 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50862 {
50863 PyThreadState* __tstate = wxPyBeginAllowThreads();
50864 delete arg1;
50865
50866 wxPyEndAllowThreads(__tstate);
50867 if (PyErr_Occurred()) SWIG_fail;
50868 }
50869 resultobj = SWIG_Py_Void();
50870 return resultobj;
50871 fail:
50872 return NULL;
50873 }
50874
50875
50876 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50877 PyObject *resultobj = 0;
50878 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50879 int result;
50880 void *argp1 = 0 ;
50881 int res1 = 0 ;
50882 PyObject *swig_obj[1] ;
50883
50884 if (!args) SWIG_fail;
50885 swig_obj[0] = args;
50886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50887 if (!SWIG_IsOK(res1)) {
50888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50889 }
50890 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50891 {
50892 PyThreadState* __tstate = wxPyBeginAllowThreads();
50893 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50894 wxPyEndAllowThreads(__tstate);
50895 if (PyErr_Occurred()) SWIG_fail;
50896 }
50897 resultobj = SWIG_From_int(static_cast< int >(result));
50898 return resultobj;
50899 fail:
50900 return NULL;
50901 }
50902
50903
50904 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50905 PyObject *resultobj = 0;
50906 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50907 int result;
50908 void *argp1 = 0 ;
50909 int res1 = 0 ;
50910 PyObject *swig_obj[1] ;
50911
50912 if (!args) SWIG_fail;
50913 swig_obj[0] = args;
50914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50915 if (!SWIG_IsOK(res1)) {
50916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50917 }
50918 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50919 {
50920 PyThreadState* __tstate = wxPyBeginAllowThreads();
50921 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50922 wxPyEndAllowThreads(__tstate);
50923 if (PyErr_Occurred()) SWIG_fail;
50924 }
50925 resultobj = SWIG_From_int(static_cast< int >(result));
50926 return resultobj;
50927 fail:
50928 return NULL;
50929 }
50930
50931
50932 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50933 PyObject *resultobj = 0;
50934 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50935 int arg2 ;
50936 void *argp1 = 0 ;
50937 int res1 = 0 ;
50938 int val2 ;
50939 int ecode2 = 0 ;
50940 PyObject * obj0 = 0 ;
50941 PyObject * obj1 = 0 ;
50942 char * kwnames[] = {
50943 (char *) "self",(char *) "rowspan", NULL
50944 };
50945
50946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50948 if (!SWIG_IsOK(res1)) {
50949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50950 }
50951 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50952 ecode2 = SWIG_AsVal_int(obj1, &val2);
50953 if (!SWIG_IsOK(ecode2)) {
50954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50955 }
50956 arg2 = static_cast< int >(val2);
50957 {
50958 PyThreadState* __tstate = wxPyBeginAllowThreads();
50959 (arg1)->SetRowspan(arg2);
50960 wxPyEndAllowThreads(__tstate);
50961 if (PyErr_Occurred()) SWIG_fail;
50962 }
50963 resultobj = SWIG_Py_Void();
50964 return resultobj;
50965 fail:
50966 return NULL;
50967 }
50968
50969
50970 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50971 PyObject *resultobj = 0;
50972 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50973 int arg2 ;
50974 void *argp1 = 0 ;
50975 int res1 = 0 ;
50976 int val2 ;
50977 int ecode2 = 0 ;
50978 PyObject * obj0 = 0 ;
50979 PyObject * obj1 = 0 ;
50980 char * kwnames[] = {
50981 (char *) "self",(char *) "colspan", NULL
50982 };
50983
50984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50986 if (!SWIG_IsOK(res1)) {
50987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50988 }
50989 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50990 ecode2 = SWIG_AsVal_int(obj1, &val2);
50991 if (!SWIG_IsOK(ecode2)) {
50992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50993 }
50994 arg2 = static_cast< int >(val2);
50995 {
50996 PyThreadState* __tstate = wxPyBeginAllowThreads();
50997 (arg1)->SetColspan(arg2);
50998 wxPyEndAllowThreads(__tstate);
50999 if (PyErr_Occurred()) SWIG_fail;
51000 }
51001 resultobj = SWIG_Py_Void();
51002 return resultobj;
51003 fail:
51004 return NULL;
51005 }
51006
51007
51008 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51009 PyObject *resultobj = 0;
51010 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51011 PyObject *arg2 = (PyObject *) 0 ;
51012 bool result;
51013 void *argp1 = 0 ;
51014 int res1 = 0 ;
51015 PyObject * obj0 = 0 ;
51016 PyObject * obj1 = 0 ;
51017 char * kwnames[] = {
51018 (char *) "self",(char *) "other", NULL
51019 };
51020
51021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
51022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51023 if (!SWIG_IsOK(res1)) {
51024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51025 }
51026 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51027 arg2 = obj1;
51028 {
51029 result = (bool)wxGBSpan___eq__(arg1,arg2);
51030 if (PyErr_Occurred()) SWIG_fail;
51031 }
51032 {
51033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51034 }
51035 return resultobj;
51036 fail:
51037 return NULL;
51038 }
51039
51040
51041 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51042 PyObject *resultobj = 0;
51043 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51044 PyObject *arg2 = (PyObject *) 0 ;
51045 bool result;
51046 void *argp1 = 0 ;
51047 int res1 = 0 ;
51048 PyObject * obj0 = 0 ;
51049 PyObject * obj1 = 0 ;
51050 char * kwnames[] = {
51051 (char *) "self",(char *) "other", NULL
51052 };
51053
51054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
51055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51056 if (!SWIG_IsOK(res1)) {
51057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51058 }
51059 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51060 arg2 = obj1;
51061 {
51062 result = (bool)wxGBSpan___ne__(arg1,arg2);
51063 if (PyErr_Occurred()) SWIG_fail;
51064 }
51065 {
51066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51067 }
51068 return resultobj;
51069 fail:
51070 return NULL;
51071 }
51072
51073
51074 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51075 PyObject *resultobj = 0;
51076 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51077 int arg2 = (int) 1 ;
51078 int arg3 = (int) 1 ;
51079 void *argp1 = 0 ;
51080 int res1 = 0 ;
51081 int val2 ;
51082 int ecode2 = 0 ;
51083 int val3 ;
51084 int ecode3 = 0 ;
51085 PyObject * obj0 = 0 ;
51086 PyObject * obj1 = 0 ;
51087 PyObject * obj2 = 0 ;
51088 char * kwnames[] = {
51089 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
51090 };
51091
51092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51094 if (!SWIG_IsOK(res1)) {
51095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51096 }
51097 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51098 if (obj1) {
51099 ecode2 = SWIG_AsVal_int(obj1, &val2);
51100 if (!SWIG_IsOK(ecode2)) {
51101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
51102 }
51103 arg2 = static_cast< int >(val2);
51104 }
51105 if (obj2) {
51106 ecode3 = SWIG_AsVal_int(obj2, &val3);
51107 if (!SWIG_IsOK(ecode3)) {
51108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
51109 }
51110 arg3 = static_cast< int >(val3);
51111 }
51112 {
51113 PyThreadState* __tstate = wxPyBeginAllowThreads();
51114 wxGBSpan_Set(arg1,arg2,arg3);
51115 wxPyEndAllowThreads(__tstate);
51116 if (PyErr_Occurred()) SWIG_fail;
51117 }
51118 resultobj = SWIG_Py_Void();
51119 return resultobj;
51120 fail:
51121 return NULL;
51122 }
51123
51124
51125 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51126 PyObject *resultobj = 0;
51127 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51128 PyObject *result = 0 ;
51129 void *argp1 = 0 ;
51130 int res1 = 0 ;
51131 PyObject *swig_obj[1] ;
51132
51133 if (!args) SWIG_fail;
51134 swig_obj[0] = args;
51135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51136 if (!SWIG_IsOK(res1)) {
51137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51138 }
51139 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51140 {
51141 PyThreadState* __tstate = wxPyBeginAllowThreads();
51142 result = (PyObject *)wxGBSpan_Get(arg1);
51143 wxPyEndAllowThreads(__tstate);
51144 if (PyErr_Occurred()) SWIG_fail;
51145 }
51146 resultobj = result;
51147 return resultobj;
51148 fail:
51149 return NULL;
51150 }
51151
51152
51153 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51154 PyObject *obj;
51155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51156 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
51157 return SWIG_Py_Void();
51158 }
51159
51160 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51161 return SWIG_Python_InitShadowInstance(args);
51162 }
51163
51164 SWIGINTERN int DefaultSpan_set(PyObject *) {
51165 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51166 return 1;
51167 }
51168
51169
51170 SWIGINTERN PyObject *DefaultSpan_get(void) {
51171 PyObject *pyobj = 0;
51172
51173 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51174 return pyobj;
51175 }
51176
51177
51178 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51179 PyObject *resultobj = 0;
51180 wxGBSizerItem *result = 0 ;
51181
51182 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51183 {
51184 PyThreadState* __tstate = wxPyBeginAllowThreads();
51185 result = (wxGBSizerItem *)new wxGBSizerItem();
51186 wxPyEndAllowThreads(__tstate);
51187 if (PyErr_Occurred()) SWIG_fail;
51188 }
51189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51190 return resultobj;
51191 fail:
51192 return NULL;
51193 }
51194
51195
51196 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51197 PyObject *resultobj = 0;
51198 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51199 void *argp1 = 0 ;
51200 int res1 = 0 ;
51201 PyObject *swig_obj[1] ;
51202
51203 if (!args) SWIG_fail;
51204 swig_obj[0] = args;
51205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51206 if (!SWIG_IsOK(res1)) {
51207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51208 }
51209 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51210 {
51211 PyThreadState* __tstate = wxPyBeginAllowThreads();
51212 delete arg1;
51213
51214 wxPyEndAllowThreads(__tstate);
51215 if (PyErr_Occurred()) SWIG_fail;
51216 }
51217 resultobj = SWIG_Py_Void();
51218 return resultobj;
51219 fail:
51220 return NULL;
51221 }
51222
51223
51224 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51225 PyObject *resultobj = 0;
51226 wxWindow *arg1 = (wxWindow *) 0 ;
51227 wxGBPosition *arg2 = 0 ;
51228 wxGBSpan *arg3 = 0 ;
51229 int arg4 ;
51230 int arg5 ;
51231 PyObject *arg6 = (PyObject *) NULL ;
51232 wxGBSizerItem *result = 0 ;
51233 void *argp1 = 0 ;
51234 int res1 = 0 ;
51235 wxGBPosition temp2 ;
51236 wxGBSpan temp3 ;
51237 int val4 ;
51238 int ecode4 = 0 ;
51239 int val5 ;
51240 int ecode5 = 0 ;
51241 PyObject * obj0 = 0 ;
51242 PyObject * obj1 = 0 ;
51243 PyObject * obj2 = 0 ;
51244 PyObject * obj3 = 0 ;
51245 PyObject * obj4 = 0 ;
51246 PyObject * obj5 = 0 ;
51247 char * kwnames[] = {
51248 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51249 };
51250
51251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51253 if (!SWIG_IsOK(res1)) {
51254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51255 }
51256 arg1 = reinterpret_cast< wxWindow * >(argp1);
51257 {
51258 arg2 = &temp2;
51259 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51260 }
51261 {
51262 arg3 = &temp3;
51263 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51264 }
51265 ecode4 = SWIG_AsVal_int(obj3, &val4);
51266 if (!SWIG_IsOK(ecode4)) {
51267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51268 }
51269 arg4 = static_cast< int >(val4);
51270 ecode5 = SWIG_AsVal_int(obj4, &val5);
51271 if (!SWIG_IsOK(ecode5)) {
51272 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51273 }
51274 arg5 = static_cast< int >(val5);
51275 if (obj5) {
51276 arg6 = obj5;
51277 }
51278 {
51279 PyThreadState* __tstate = wxPyBeginAllowThreads();
51280 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51281 wxPyEndAllowThreads(__tstate);
51282 if (PyErr_Occurred()) SWIG_fail;
51283 }
51284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51285 return resultobj;
51286 fail:
51287 return NULL;
51288 }
51289
51290
51291 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51292 PyObject *resultobj = 0;
51293 wxSizer *arg1 = (wxSizer *) 0 ;
51294 wxGBPosition *arg2 = 0 ;
51295 wxGBSpan *arg3 = 0 ;
51296 int arg4 ;
51297 int arg5 ;
51298 PyObject *arg6 = (PyObject *) NULL ;
51299 wxGBSizerItem *result = 0 ;
51300 int res1 = 0 ;
51301 wxGBPosition temp2 ;
51302 wxGBSpan temp3 ;
51303 int val4 ;
51304 int ecode4 = 0 ;
51305 int val5 ;
51306 int ecode5 = 0 ;
51307 PyObject * obj0 = 0 ;
51308 PyObject * obj1 = 0 ;
51309 PyObject * obj2 = 0 ;
51310 PyObject * obj3 = 0 ;
51311 PyObject * obj4 = 0 ;
51312 PyObject * obj5 = 0 ;
51313 char * kwnames[] = {
51314 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51315 };
51316
51317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51318 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51319 if (!SWIG_IsOK(res1)) {
51320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51321 }
51322 {
51323 arg2 = &temp2;
51324 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51325 }
51326 {
51327 arg3 = &temp3;
51328 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51329 }
51330 ecode4 = SWIG_AsVal_int(obj3, &val4);
51331 if (!SWIG_IsOK(ecode4)) {
51332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51333 }
51334 arg4 = static_cast< int >(val4);
51335 ecode5 = SWIG_AsVal_int(obj4, &val5);
51336 if (!SWIG_IsOK(ecode5)) {
51337 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51338 }
51339 arg5 = static_cast< int >(val5);
51340 if (obj5) {
51341 arg6 = obj5;
51342 }
51343 {
51344 PyThreadState* __tstate = wxPyBeginAllowThreads();
51345 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51346 wxPyEndAllowThreads(__tstate);
51347 if (PyErr_Occurred()) SWIG_fail;
51348 }
51349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51350 return resultobj;
51351 fail:
51352 return NULL;
51353 }
51354
51355
51356 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51357 PyObject *resultobj = 0;
51358 int arg1 ;
51359 int arg2 ;
51360 wxGBPosition *arg3 = 0 ;
51361 wxGBSpan *arg4 = 0 ;
51362 int arg5 ;
51363 int arg6 ;
51364 PyObject *arg7 = (PyObject *) NULL ;
51365 wxGBSizerItem *result = 0 ;
51366 int val1 ;
51367 int ecode1 = 0 ;
51368 int val2 ;
51369 int ecode2 = 0 ;
51370 wxGBPosition temp3 ;
51371 wxGBSpan temp4 ;
51372 int val5 ;
51373 int ecode5 = 0 ;
51374 int val6 ;
51375 int ecode6 = 0 ;
51376 PyObject * obj0 = 0 ;
51377 PyObject * obj1 = 0 ;
51378 PyObject * obj2 = 0 ;
51379 PyObject * obj3 = 0 ;
51380 PyObject * obj4 = 0 ;
51381 PyObject * obj5 = 0 ;
51382 PyObject * obj6 = 0 ;
51383 char * kwnames[] = {
51384 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51385 };
51386
51387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51388 ecode1 = SWIG_AsVal_int(obj0, &val1);
51389 if (!SWIG_IsOK(ecode1)) {
51390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51391 }
51392 arg1 = static_cast< int >(val1);
51393 ecode2 = SWIG_AsVal_int(obj1, &val2);
51394 if (!SWIG_IsOK(ecode2)) {
51395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51396 }
51397 arg2 = static_cast< int >(val2);
51398 {
51399 arg3 = &temp3;
51400 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51401 }
51402 {
51403 arg4 = &temp4;
51404 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51405 }
51406 ecode5 = SWIG_AsVal_int(obj4, &val5);
51407 if (!SWIG_IsOK(ecode5)) {
51408 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51409 }
51410 arg5 = static_cast< int >(val5);
51411 ecode6 = SWIG_AsVal_int(obj5, &val6);
51412 if (!SWIG_IsOK(ecode6)) {
51413 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51414 }
51415 arg6 = static_cast< int >(val6);
51416 if (obj6) {
51417 arg7 = obj6;
51418 }
51419 {
51420 PyThreadState* __tstate = wxPyBeginAllowThreads();
51421 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51422 wxPyEndAllowThreads(__tstate);
51423 if (PyErr_Occurred()) SWIG_fail;
51424 }
51425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51426 return resultobj;
51427 fail:
51428 return NULL;
51429 }
51430
51431
51432 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51433 PyObject *resultobj = 0;
51434 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51435 wxGBPosition result;
51436 void *argp1 = 0 ;
51437 int res1 = 0 ;
51438 PyObject *swig_obj[1] ;
51439
51440 if (!args) SWIG_fail;
51441 swig_obj[0] = args;
51442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51443 if (!SWIG_IsOK(res1)) {
51444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51445 }
51446 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51447 {
51448 PyThreadState* __tstate = wxPyBeginAllowThreads();
51449 result = ((wxGBSizerItem const *)arg1)->GetPos();
51450 wxPyEndAllowThreads(__tstate);
51451 if (PyErr_Occurred()) SWIG_fail;
51452 }
51453 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51454 return resultobj;
51455 fail:
51456 return NULL;
51457 }
51458
51459
51460 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51461 PyObject *resultobj = 0;
51462 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51463 wxGBSpan result;
51464 void *argp1 = 0 ;
51465 int res1 = 0 ;
51466 PyObject *swig_obj[1] ;
51467
51468 if (!args) SWIG_fail;
51469 swig_obj[0] = args;
51470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51471 if (!SWIG_IsOK(res1)) {
51472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51473 }
51474 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51475 {
51476 PyThreadState* __tstate = wxPyBeginAllowThreads();
51477 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51478 wxPyEndAllowThreads(__tstate);
51479 if (PyErr_Occurred()) SWIG_fail;
51480 }
51481 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51482 return resultobj;
51483 fail:
51484 return NULL;
51485 }
51486
51487
51488 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51489 PyObject *resultobj = 0;
51490 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51491 wxGBPosition *arg2 = 0 ;
51492 bool result;
51493 void *argp1 = 0 ;
51494 int res1 = 0 ;
51495 wxGBPosition temp2 ;
51496 PyObject * obj0 = 0 ;
51497 PyObject * obj1 = 0 ;
51498 char * kwnames[] = {
51499 (char *) "self",(char *) "pos", NULL
51500 };
51501
51502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51504 if (!SWIG_IsOK(res1)) {
51505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51506 }
51507 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51508 {
51509 arg2 = &temp2;
51510 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51511 }
51512 {
51513 PyThreadState* __tstate = wxPyBeginAllowThreads();
51514 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51515 wxPyEndAllowThreads(__tstate);
51516 if (PyErr_Occurred()) SWIG_fail;
51517 }
51518 {
51519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51520 }
51521 return resultobj;
51522 fail:
51523 return NULL;
51524 }
51525
51526
51527 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51528 PyObject *resultobj = 0;
51529 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51530 wxGBSpan *arg2 = 0 ;
51531 bool result;
51532 void *argp1 = 0 ;
51533 int res1 = 0 ;
51534 wxGBSpan temp2 ;
51535 PyObject * obj0 = 0 ;
51536 PyObject * obj1 = 0 ;
51537 char * kwnames[] = {
51538 (char *) "self",(char *) "span", NULL
51539 };
51540
51541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51543 if (!SWIG_IsOK(res1)) {
51544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51545 }
51546 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51547 {
51548 arg2 = &temp2;
51549 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51550 }
51551 {
51552 PyThreadState* __tstate = wxPyBeginAllowThreads();
51553 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51554 wxPyEndAllowThreads(__tstate);
51555 if (PyErr_Occurred()) SWIG_fail;
51556 }
51557 {
51558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51559 }
51560 return resultobj;
51561 fail:
51562 return NULL;
51563 }
51564
51565
51566 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51567 PyObject *resultobj = 0;
51568 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51569 wxGBSizerItem *arg2 = 0 ;
51570 bool result;
51571 void *argp1 = 0 ;
51572 int res1 = 0 ;
51573 void *argp2 = 0 ;
51574 int res2 = 0 ;
51575 PyObject * obj0 = 0 ;
51576 PyObject * obj1 = 0 ;
51577 char * kwnames[] = {
51578 (char *) "self",(char *) "other", NULL
51579 };
51580
51581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51583 if (!SWIG_IsOK(res1)) {
51584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51585 }
51586 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51588 if (!SWIG_IsOK(res2)) {
51589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51590 }
51591 if (!argp2) {
51592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51593 }
51594 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51595 {
51596 PyThreadState* __tstate = wxPyBeginAllowThreads();
51597 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51598 wxPyEndAllowThreads(__tstate);
51599 if (PyErr_Occurred()) SWIG_fail;
51600 }
51601 {
51602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51603 }
51604 return resultobj;
51605 fail:
51606 return NULL;
51607 }
51608
51609
51610 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51611 PyObject *resultobj = 0;
51612 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51613 wxGBPosition *arg2 = 0 ;
51614 wxGBSpan *arg3 = 0 ;
51615 bool result;
51616 void *argp1 = 0 ;
51617 int res1 = 0 ;
51618 wxGBPosition temp2 ;
51619 wxGBSpan temp3 ;
51620 PyObject * obj0 = 0 ;
51621 PyObject * obj1 = 0 ;
51622 PyObject * obj2 = 0 ;
51623 char * kwnames[] = {
51624 (char *) "self",(char *) "pos",(char *) "span", NULL
51625 };
51626
51627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51629 if (!SWIG_IsOK(res1)) {
51630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51631 }
51632 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51633 {
51634 arg2 = &temp2;
51635 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51636 }
51637 {
51638 arg3 = &temp3;
51639 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51640 }
51641 {
51642 PyThreadState* __tstate = wxPyBeginAllowThreads();
51643 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51644 wxPyEndAllowThreads(__tstate);
51645 if (PyErr_Occurred()) SWIG_fail;
51646 }
51647 {
51648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51649 }
51650 return resultobj;
51651 fail:
51652 return NULL;
51653 }
51654
51655
51656 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51657 PyObject *resultobj = 0;
51658 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51659 wxGBPosition result;
51660 void *argp1 = 0 ;
51661 int res1 = 0 ;
51662 PyObject *swig_obj[1] ;
51663
51664 if (!args) SWIG_fail;
51665 swig_obj[0] = args;
51666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51667 if (!SWIG_IsOK(res1)) {
51668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51669 }
51670 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51671 {
51672 PyThreadState* __tstate = wxPyBeginAllowThreads();
51673 result = wxGBSizerItem_GetEndPos(arg1);
51674 wxPyEndAllowThreads(__tstate);
51675 if (PyErr_Occurred()) SWIG_fail;
51676 }
51677 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51678 return resultobj;
51679 fail:
51680 return NULL;
51681 }
51682
51683
51684 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51685 PyObject *resultobj = 0;
51686 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51687 wxGridBagSizer *result = 0 ;
51688 void *argp1 = 0 ;
51689 int res1 = 0 ;
51690 PyObject *swig_obj[1] ;
51691
51692 if (!args) SWIG_fail;
51693 swig_obj[0] = args;
51694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51695 if (!SWIG_IsOK(res1)) {
51696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51697 }
51698 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51699 {
51700 PyThreadState* __tstate = wxPyBeginAllowThreads();
51701 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51702 wxPyEndAllowThreads(__tstate);
51703 if (PyErr_Occurred()) SWIG_fail;
51704 }
51705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51706 return resultobj;
51707 fail:
51708 return NULL;
51709 }
51710
51711
51712 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51713 PyObject *resultobj = 0;
51714 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51715 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51716 void *argp1 = 0 ;
51717 int res1 = 0 ;
51718 void *argp2 = 0 ;
51719 int res2 = 0 ;
51720 PyObject * obj0 = 0 ;
51721 PyObject * obj1 = 0 ;
51722 char * kwnames[] = {
51723 (char *) "self",(char *) "sizer", NULL
51724 };
51725
51726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51728 if (!SWIG_IsOK(res1)) {
51729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51730 }
51731 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51733 if (!SWIG_IsOK(res2)) {
51734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51735 }
51736 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51737 {
51738 PyThreadState* __tstate = wxPyBeginAllowThreads();
51739 (arg1)->SetGBSizer(arg2);
51740 wxPyEndAllowThreads(__tstate);
51741 if (PyErr_Occurred()) SWIG_fail;
51742 }
51743 resultobj = SWIG_Py_Void();
51744 return resultobj;
51745 fail:
51746 return NULL;
51747 }
51748
51749
51750 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51751 PyObject *obj;
51752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51753 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51754 return SWIG_Py_Void();
51755 }
51756
51757 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51758 return SWIG_Python_InitShadowInstance(args);
51759 }
51760
51761 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51762 PyObject *resultobj = 0;
51763 int arg1 = (int) 0 ;
51764 int arg2 = (int) 0 ;
51765 wxGridBagSizer *result = 0 ;
51766 int val1 ;
51767 int ecode1 = 0 ;
51768 int val2 ;
51769 int ecode2 = 0 ;
51770 PyObject * obj0 = 0 ;
51771 PyObject * obj1 = 0 ;
51772 char * kwnames[] = {
51773 (char *) "vgap",(char *) "hgap", NULL
51774 };
51775
51776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51777 if (obj0) {
51778 ecode1 = SWIG_AsVal_int(obj0, &val1);
51779 if (!SWIG_IsOK(ecode1)) {
51780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51781 }
51782 arg1 = static_cast< int >(val1);
51783 }
51784 if (obj1) {
51785 ecode2 = SWIG_AsVal_int(obj1, &val2);
51786 if (!SWIG_IsOK(ecode2)) {
51787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51788 }
51789 arg2 = static_cast< int >(val2);
51790 }
51791 {
51792 PyThreadState* __tstate = wxPyBeginAllowThreads();
51793 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51794 wxPyEndAllowThreads(__tstate);
51795 if (PyErr_Occurred()) SWIG_fail;
51796 }
51797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51798 return resultobj;
51799 fail:
51800 return NULL;
51801 }
51802
51803
51804 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51805 PyObject *resultobj = 0;
51806 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51807 PyObject *arg2 = (PyObject *) 0 ;
51808 wxGBPosition *arg3 = 0 ;
51809 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51810 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51811 int arg5 = (int) 0 ;
51812 int arg6 = (int) 0 ;
51813 PyObject *arg7 = (PyObject *) NULL ;
51814 wxGBSizerItem *result = 0 ;
51815 void *argp1 = 0 ;
51816 int res1 = 0 ;
51817 wxGBPosition temp3 ;
51818 wxGBSpan temp4 ;
51819 int val5 ;
51820 int ecode5 = 0 ;
51821 int val6 ;
51822 int ecode6 = 0 ;
51823 PyObject * obj0 = 0 ;
51824 PyObject * obj1 = 0 ;
51825 PyObject * obj2 = 0 ;
51826 PyObject * obj3 = 0 ;
51827 PyObject * obj4 = 0 ;
51828 PyObject * obj5 = 0 ;
51829 PyObject * obj6 = 0 ;
51830 char * kwnames[] = {
51831 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51832 };
51833
51834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51836 if (!SWIG_IsOK(res1)) {
51837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51838 }
51839 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51840 arg2 = obj1;
51841 {
51842 arg3 = &temp3;
51843 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51844 }
51845 if (obj3) {
51846 {
51847 arg4 = &temp4;
51848 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51849 }
51850 }
51851 if (obj4) {
51852 ecode5 = SWIG_AsVal_int(obj4, &val5);
51853 if (!SWIG_IsOK(ecode5)) {
51854 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51855 }
51856 arg5 = static_cast< int >(val5);
51857 }
51858 if (obj5) {
51859 ecode6 = SWIG_AsVal_int(obj5, &val6);
51860 if (!SWIG_IsOK(ecode6)) {
51861 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51862 }
51863 arg6 = static_cast< int >(val6);
51864 }
51865 if (obj6) {
51866 arg7 = obj6;
51867 }
51868 {
51869 PyThreadState* __tstate = wxPyBeginAllowThreads();
51870 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51871 wxPyEndAllowThreads(__tstate);
51872 if (PyErr_Occurred()) SWIG_fail;
51873 }
51874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51875 return resultobj;
51876 fail:
51877 return NULL;
51878 }
51879
51880
51881 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51882 PyObject *resultobj = 0;
51883 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51884 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51885 wxGBSizerItem *result = 0 ;
51886 void *argp1 = 0 ;
51887 int res1 = 0 ;
51888 int res2 = 0 ;
51889 PyObject * obj0 = 0 ;
51890 PyObject * obj1 = 0 ;
51891 char * kwnames[] = {
51892 (char *) "self",(char *) "item", NULL
51893 };
51894
51895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51897 if (!SWIG_IsOK(res1)) {
51898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51899 }
51900 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51901 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51902 if (!SWIG_IsOK(res2)) {
51903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51904 }
51905 {
51906 PyThreadState* __tstate = wxPyBeginAllowThreads();
51907 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51908 wxPyEndAllowThreads(__tstate);
51909 if (PyErr_Occurred()) SWIG_fail;
51910 }
51911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51912 return resultobj;
51913 fail:
51914 return NULL;
51915 }
51916
51917
51918 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51919 PyObject *resultobj = 0;
51920 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51921 int arg2 ;
51922 int arg3 ;
51923 wxSize result;
51924 void *argp1 = 0 ;
51925 int res1 = 0 ;
51926 int val2 ;
51927 int ecode2 = 0 ;
51928 int val3 ;
51929 int ecode3 = 0 ;
51930 PyObject * obj0 = 0 ;
51931 PyObject * obj1 = 0 ;
51932 PyObject * obj2 = 0 ;
51933 char * kwnames[] = {
51934 (char *) "self",(char *) "row",(char *) "col", NULL
51935 };
51936
51937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51939 if (!SWIG_IsOK(res1)) {
51940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51941 }
51942 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51943 ecode2 = SWIG_AsVal_int(obj1, &val2);
51944 if (!SWIG_IsOK(ecode2)) {
51945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51946 }
51947 arg2 = static_cast< int >(val2);
51948 ecode3 = SWIG_AsVal_int(obj2, &val3);
51949 if (!SWIG_IsOK(ecode3)) {
51950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51951 }
51952 arg3 = static_cast< int >(val3);
51953 {
51954 PyThreadState* __tstate = wxPyBeginAllowThreads();
51955 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51956 wxPyEndAllowThreads(__tstate);
51957 if (PyErr_Occurred()) SWIG_fail;
51958 }
51959 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51960 return resultobj;
51961 fail:
51962 return NULL;
51963 }
51964
51965
51966 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51967 PyObject *resultobj = 0;
51968 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51969 wxSize result;
51970 void *argp1 = 0 ;
51971 int res1 = 0 ;
51972 PyObject *swig_obj[1] ;
51973
51974 if (!args) SWIG_fail;
51975 swig_obj[0] = args;
51976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51977 if (!SWIG_IsOK(res1)) {
51978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51979 }
51980 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51981 {
51982 PyThreadState* __tstate = wxPyBeginAllowThreads();
51983 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51984 wxPyEndAllowThreads(__tstate);
51985 if (PyErr_Occurred()) SWIG_fail;
51986 }
51987 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51988 return resultobj;
51989 fail:
51990 return NULL;
51991 }
51992
51993
51994 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51995 PyObject *resultobj = 0;
51996 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51997 wxSize *arg2 = 0 ;
51998 void *argp1 = 0 ;
51999 int res1 = 0 ;
52000 wxSize temp2 ;
52001 PyObject * obj0 = 0 ;
52002 PyObject * obj1 = 0 ;
52003 char * kwnames[] = {
52004 (char *) "self",(char *) "sz", NULL
52005 };
52006
52007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
52008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52009 if (!SWIG_IsOK(res1)) {
52010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52011 }
52012 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52013 {
52014 arg2 = &temp2;
52015 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52016 }
52017 {
52018 PyThreadState* __tstate = wxPyBeginAllowThreads();
52019 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
52020 wxPyEndAllowThreads(__tstate);
52021 if (PyErr_Occurred()) SWIG_fail;
52022 }
52023 resultobj = SWIG_Py_Void();
52024 return resultobj;
52025 fail:
52026 return NULL;
52027 }
52028
52029
52030 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52031 PyObject *resultobj = 0;
52032 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52033 wxWindow *arg2 = (wxWindow *) 0 ;
52034 wxGBPosition result;
52035 void *argp1 = 0 ;
52036 int res1 = 0 ;
52037 void *argp2 = 0 ;
52038 int res2 = 0 ;
52039
52040 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52042 if (!SWIG_IsOK(res1)) {
52043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52044 }
52045 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52046 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52047 if (!SWIG_IsOK(res2)) {
52048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52049 }
52050 arg2 = reinterpret_cast< wxWindow * >(argp2);
52051 {
52052 PyThreadState* __tstate = wxPyBeginAllowThreads();
52053 result = (arg1)->GetItemPosition(arg2);
52054 wxPyEndAllowThreads(__tstate);
52055 if (PyErr_Occurred()) SWIG_fail;
52056 }
52057 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52058 return resultobj;
52059 fail:
52060 return NULL;
52061 }
52062
52063
52064 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52065 PyObject *resultobj = 0;
52066 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52067 wxSizer *arg2 = (wxSizer *) 0 ;
52068 wxGBPosition result;
52069 void *argp1 = 0 ;
52070 int res1 = 0 ;
52071 void *argp2 = 0 ;
52072 int res2 = 0 ;
52073
52074 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52076 if (!SWIG_IsOK(res1)) {
52077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52078 }
52079 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52080 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52081 if (!SWIG_IsOK(res2)) {
52082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52083 }
52084 arg2 = reinterpret_cast< wxSizer * >(argp2);
52085 {
52086 PyThreadState* __tstate = wxPyBeginAllowThreads();
52087 result = (arg1)->GetItemPosition(arg2);
52088 wxPyEndAllowThreads(__tstate);
52089 if (PyErr_Occurred()) SWIG_fail;
52090 }
52091 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52092 return resultobj;
52093 fail:
52094 return NULL;
52095 }
52096
52097
52098 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52099 PyObject *resultobj = 0;
52100 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52101 size_t arg2 ;
52102 wxGBPosition result;
52103 void *argp1 = 0 ;
52104 int res1 = 0 ;
52105 size_t val2 ;
52106 int ecode2 = 0 ;
52107
52108 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52110 if (!SWIG_IsOK(res1)) {
52111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52112 }
52113 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52114 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52115 if (!SWIG_IsOK(ecode2)) {
52116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52117 }
52118 arg2 = static_cast< size_t >(val2);
52119 {
52120 PyThreadState* __tstate = wxPyBeginAllowThreads();
52121 result = (arg1)->GetItemPosition(arg2);
52122 wxPyEndAllowThreads(__tstate);
52123 if (PyErr_Occurred()) SWIG_fail;
52124 }
52125 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52126 return resultobj;
52127 fail:
52128 return NULL;
52129 }
52130
52131
52132 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
52133 int argc;
52134 PyObject *argv[3];
52135
52136 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
52137 --argc;
52138 if (argc == 2) {
52139 int _v = 0;
52140 {
52141 void *vptr = 0;
52142 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52143 _v = SWIG_CheckState(res);
52144 }
52145 if (!_v) goto check_1;
52146 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
52147 }
52148 check_1:
52149
52150 if (argc == 2) {
52151 int _v = 0;
52152 {
52153 void *vptr = 0;
52154 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52155 _v = SWIG_CheckState(res);
52156 }
52157 if (!_v) goto check_2;
52158 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
52159 }
52160 check_2:
52161
52162 if (argc == 2) {
52163 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52164 }
52165
52166 fail:
52167 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52168 return NULL;
52169 }
52170
52171
52172 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52173 PyObject *resultobj = 0;
52174 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52175 wxWindow *arg2 = (wxWindow *) 0 ;
52176 wxGBPosition *arg3 = 0 ;
52177 bool result;
52178 void *argp1 = 0 ;
52179 int res1 = 0 ;
52180 void *argp2 = 0 ;
52181 int res2 = 0 ;
52182 wxGBPosition temp3 ;
52183
52184 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52186 if (!SWIG_IsOK(res1)) {
52187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52188 }
52189 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52190 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52191 if (!SWIG_IsOK(res2)) {
52192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52193 }
52194 arg2 = reinterpret_cast< wxWindow * >(argp2);
52195 {
52196 arg3 = &temp3;
52197 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52198 }
52199 {
52200 PyThreadState* __tstate = wxPyBeginAllowThreads();
52201 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52202 wxPyEndAllowThreads(__tstate);
52203 if (PyErr_Occurred()) SWIG_fail;
52204 }
52205 {
52206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52207 }
52208 return resultobj;
52209 fail:
52210 return NULL;
52211 }
52212
52213
52214 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52215 PyObject *resultobj = 0;
52216 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52217 wxSizer *arg2 = (wxSizer *) 0 ;
52218 wxGBPosition *arg3 = 0 ;
52219 bool result;
52220 void *argp1 = 0 ;
52221 int res1 = 0 ;
52222 void *argp2 = 0 ;
52223 int res2 = 0 ;
52224 wxGBPosition temp3 ;
52225
52226 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52228 if (!SWIG_IsOK(res1)) {
52229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52230 }
52231 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52232 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52233 if (!SWIG_IsOK(res2)) {
52234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52235 }
52236 arg2 = reinterpret_cast< wxSizer * >(argp2);
52237 {
52238 arg3 = &temp3;
52239 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52240 }
52241 {
52242 PyThreadState* __tstate = wxPyBeginAllowThreads();
52243 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52244 wxPyEndAllowThreads(__tstate);
52245 if (PyErr_Occurred()) SWIG_fail;
52246 }
52247 {
52248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52249 }
52250 return resultobj;
52251 fail:
52252 return NULL;
52253 }
52254
52255
52256 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52257 PyObject *resultobj = 0;
52258 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52259 size_t arg2 ;
52260 wxGBPosition *arg3 = 0 ;
52261 bool result;
52262 void *argp1 = 0 ;
52263 int res1 = 0 ;
52264 size_t val2 ;
52265 int ecode2 = 0 ;
52266 wxGBPosition temp3 ;
52267
52268 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52270 if (!SWIG_IsOK(res1)) {
52271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52272 }
52273 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52274 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52275 if (!SWIG_IsOK(ecode2)) {
52276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52277 }
52278 arg2 = static_cast< size_t >(val2);
52279 {
52280 arg3 = &temp3;
52281 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52282 }
52283 {
52284 PyThreadState* __tstate = wxPyBeginAllowThreads();
52285 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52286 wxPyEndAllowThreads(__tstate);
52287 if (PyErr_Occurred()) SWIG_fail;
52288 }
52289 {
52290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52291 }
52292 return resultobj;
52293 fail:
52294 return NULL;
52295 }
52296
52297
52298 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52299 int argc;
52300 PyObject *argv[4];
52301
52302 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52303 --argc;
52304 if (argc == 3) {
52305 int _v = 0;
52306 {
52307 void *vptr = 0;
52308 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52309 _v = SWIG_CheckState(res);
52310 }
52311 if (!_v) goto check_1;
52312 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52313 }
52314 check_1:
52315
52316 if (argc == 3) {
52317 int _v = 0;
52318 {
52319 void *vptr = 0;
52320 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52321 _v = SWIG_CheckState(res);
52322 }
52323 if (!_v) goto check_2;
52324 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52325 }
52326 check_2:
52327
52328 if (argc == 3) {
52329 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52330 }
52331
52332 fail:
52333 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52334 return NULL;
52335 }
52336
52337
52338 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52339 PyObject *resultobj = 0;
52340 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52341 wxWindow *arg2 = (wxWindow *) 0 ;
52342 wxGBSpan result;
52343 void *argp1 = 0 ;
52344 int res1 = 0 ;
52345 void *argp2 = 0 ;
52346 int res2 = 0 ;
52347
52348 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52350 if (!SWIG_IsOK(res1)) {
52351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52352 }
52353 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52354 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52355 if (!SWIG_IsOK(res2)) {
52356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52357 }
52358 arg2 = reinterpret_cast< wxWindow * >(argp2);
52359 {
52360 PyThreadState* __tstate = wxPyBeginAllowThreads();
52361 result = (arg1)->GetItemSpan(arg2);
52362 wxPyEndAllowThreads(__tstate);
52363 if (PyErr_Occurred()) SWIG_fail;
52364 }
52365 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52366 return resultobj;
52367 fail:
52368 return NULL;
52369 }
52370
52371
52372 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52373 PyObject *resultobj = 0;
52374 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52375 wxSizer *arg2 = (wxSizer *) 0 ;
52376 wxGBSpan result;
52377 void *argp1 = 0 ;
52378 int res1 = 0 ;
52379 void *argp2 = 0 ;
52380 int res2 = 0 ;
52381
52382 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52384 if (!SWIG_IsOK(res1)) {
52385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52386 }
52387 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52388 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52389 if (!SWIG_IsOK(res2)) {
52390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52391 }
52392 arg2 = reinterpret_cast< wxSizer * >(argp2);
52393 {
52394 PyThreadState* __tstate = wxPyBeginAllowThreads();
52395 result = (arg1)->GetItemSpan(arg2);
52396 wxPyEndAllowThreads(__tstate);
52397 if (PyErr_Occurred()) SWIG_fail;
52398 }
52399 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52400 return resultobj;
52401 fail:
52402 return NULL;
52403 }
52404
52405
52406 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52407 PyObject *resultobj = 0;
52408 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52409 size_t arg2 ;
52410 wxGBSpan result;
52411 void *argp1 = 0 ;
52412 int res1 = 0 ;
52413 size_t val2 ;
52414 int ecode2 = 0 ;
52415
52416 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52418 if (!SWIG_IsOK(res1)) {
52419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52420 }
52421 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52422 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52423 if (!SWIG_IsOK(ecode2)) {
52424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52425 }
52426 arg2 = static_cast< size_t >(val2);
52427 {
52428 PyThreadState* __tstate = wxPyBeginAllowThreads();
52429 result = (arg1)->GetItemSpan(arg2);
52430 wxPyEndAllowThreads(__tstate);
52431 if (PyErr_Occurred()) SWIG_fail;
52432 }
52433 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52434 return resultobj;
52435 fail:
52436 return NULL;
52437 }
52438
52439
52440 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52441 int argc;
52442 PyObject *argv[3];
52443
52444 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52445 --argc;
52446 if (argc == 2) {
52447 int _v = 0;
52448 {
52449 void *vptr = 0;
52450 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52451 _v = SWIG_CheckState(res);
52452 }
52453 if (!_v) goto check_1;
52454 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52455 }
52456 check_1:
52457
52458 if (argc == 2) {
52459 int _v = 0;
52460 {
52461 void *vptr = 0;
52462 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52463 _v = SWIG_CheckState(res);
52464 }
52465 if (!_v) goto check_2;
52466 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52467 }
52468 check_2:
52469
52470 if (argc == 2) {
52471 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52472 }
52473
52474 fail:
52475 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52476 return NULL;
52477 }
52478
52479
52480 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52481 PyObject *resultobj = 0;
52482 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52483 wxWindow *arg2 = (wxWindow *) 0 ;
52484 wxGBSpan *arg3 = 0 ;
52485 bool result;
52486 void *argp1 = 0 ;
52487 int res1 = 0 ;
52488 void *argp2 = 0 ;
52489 int res2 = 0 ;
52490 wxGBSpan temp3 ;
52491
52492 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52494 if (!SWIG_IsOK(res1)) {
52495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52496 }
52497 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52498 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52499 if (!SWIG_IsOK(res2)) {
52500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52501 }
52502 arg2 = reinterpret_cast< wxWindow * >(argp2);
52503 {
52504 arg3 = &temp3;
52505 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52506 }
52507 {
52508 PyThreadState* __tstate = wxPyBeginAllowThreads();
52509 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52510 wxPyEndAllowThreads(__tstate);
52511 if (PyErr_Occurred()) SWIG_fail;
52512 }
52513 {
52514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52515 }
52516 return resultobj;
52517 fail:
52518 return NULL;
52519 }
52520
52521
52522 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52523 PyObject *resultobj = 0;
52524 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52525 wxSizer *arg2 = (wxSizer *) 0 ;
52526 wxGBSpan *arg3 = 0 ;
52527 bool result;
52528 void *argp1 = 0 ;
52529 int res1 = 0 ;
52530 void *argp2 = 0 ;
52531 int res2 = 0 ;
52532 wxGBSpan temp3 ;
52533
52534 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52536 if (!SWIG_IsOK(res1)) {
52537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52538 }
52539 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52540 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52541 if (!SWIG_IsOK(res2)) {
52542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52543 }
52544 arg2 = reinterpret_cast< wxSizer * >(argp2);
52545 {
52546 arg3 = &temp3;
52547 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52548 }
52549 {
52550 PyThreadState* __tstate = wxPyBeginAllowThreads();
52551 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52552 wxPyEndAllowThreads(__tstate);
52553 if (PyErr_Occurred()) SWIG_fail;
52554 }
52555 {
52556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52557 }
52558 return resultobj;
52559 fail:
52560 return NULL;
52561 }
52562
52563
52564 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52565 PyObject *resultobj = 0;
52566 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52567 size_t arg2 ;
52568 wxGBSpan *arg3 = 0 ;
52569 bool result;
52570 void *argp1 = 0 ;
52571 int res1 = 0 ;
52572 size_t val2 ;
52573 int ecode2 = 0 ;
52574 wxGBSpan temp3 ;
52575
52576 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52578 if (!SWIG_IsOK(res1)) {
52579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52580 }
52581 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52582 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52583 if (!SWIG_IsOK(ecode2)) {
52584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52585 }
52586 arg2 = static_cast< size_t >(val2);
52587 {
52588 arg3 = &temp3;
52589 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52590 }
52591 {
52592 PyThreadState* __tstate = wxPyBeginAllowThreads();
52593 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52594 wxPyEndAllowThreads(__tstate);
52595 if (PyErr_Occurred()) SWIG_fail;
52596 }
52597 {
52598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52599 }
52600 return resultobj;
52601 fail:
52602 return NULL;
52603 }
52604
52605
52606 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52607 int argc;
52608 PyObject *argv[4];
52609
52610 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52611 --argc;
52612 if (argc == 3) {
52613 int _v = 0;
52614 {
52615 void *vptr = 0;
52616 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52617 _v = SWIG_CheckState(res);
52618 }
52619 if (!_v) goto check_1;
52620 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52621 }
52622 check_1:
52623
52624 if (argc == 3) {
52625 int _v = 0;
52626 {
52627 void *vptr = 0;
52628 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52629 _v = SWIG_CheckState(res);
52630 }
52631 if (!_v) goto check_2;
52632 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52633 }
52634 check_2:
52635
52636 if (argc == 3) {
52637 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52638 }
52639
52640 fail:
52641 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52642 return NULL;
52643 }
52644
52645
52646 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52647 PyObject *resultobj = 0;
52648 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52649 wxWindow *arg2 = (wxWindow *) 0 ;
52650 wxGBSizerItem *result = 0 ;
52651 void *argp1 = 0 ;
52652 int res1 = 0 ;
52653 void *argp2 = 0 ;
52654 int res2 = 0 ;
52655
52656 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52658 if (!SWIG_IsOK(res1)) {
52659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52660 }
52661 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52662 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52663 if (!SWIG_IsOK(res2)) {
52664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52665 }
52666 arg2 = reinterpret_cast< wxWindow * >(argp2);
52667 {
52668 PyThreadState* __tstate = wxPyBeginAllowThreads();
52669 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52670 wxPyEndAllowThreads(__tstate);
52671 if (PyErr_Occurred()) SWIG_fail;
52672 }
52673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52674 return resultobj;
52675 fail:
52676 return NULL;
52677 }
52678
52679
52680 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52681 PyObject *resultobj = 0;
52682 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52683 wxSizer *arg2 = (wxSizer *) 0 ;
52684 wxGBSizerItem *result = 0 ;
52685 void *argp1 = 0 ;
52686 int res1 = 0 ;
52687 void *argp2 = 0 ;
52688 int res2 = 0 ;
52689
52690 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52692 if (!SWIG_IsOK(res1)) {
52693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52694 }
52695 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52696 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52697 if (!SWIG_IsOK(res2)) {
52698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52699 }
52700 arg2 = reinterpret_cast< wxSizer * >(argp2);
52701 {
52702 PyThreadState* __tstate = wxPyBeginAllowThreads();
52703 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52704 wxPyEndAllowThreads(__tstate);
52705 if (PyErr_Occurred()) SWIG_fail;
52706 }
52707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52708 return resultobj;
52709 fail:
52710 return NULL;
52711 }
52712
52713
52714 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52715 int argc;
52716 PyObject *argv[3];
52717
52718 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52719 --argc;
52720 if (argc == 2) {
52721 int _v = 0;
52722 {
52723 void *vptr = 0;
52724 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52725 _v = SWIG_CheckState(res);
52726 }
52727 if (!_v) goto check_1;
52728 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52729 }
52730 check_1:
52731
52732 if (argc == 2) {
52733 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52734 }
52735
52736 fail:
52737 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52738 return NULL;
52739 }
52740
52741
52742 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52743 PyObject *resultobj = 0;
52744 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52745 wxGBPosition *arg2 = 0 ;
52746 wxGBSizerItem *result = 0 ;
52747 void *argp1 = 0 ;
52748 int res1 = 0 ;
52749 wxGBPosition temp2 ;
52750 PyObject * obj0 = 0 ;
52751 PyObject * obj1 = 0 ;
52752 char * kwnames[] = {
52753 (char *) "self",(char *) "pos", NULL
52754 };
52755
52756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52758 if (!SWIG_IsOK(res1)) {
52759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52760 }
52761 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52762 {
52763 arg2 = &temp2;
52764 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52765 }
52766 {
52767 PyThreadState* __tstate = wxPyBeginAllowThreads();
52768 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52769 wxPyEndAllowThreads(__tstate);
52770 if (PyErr_Occurred()) SWIG_fail;
52771 }
52772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52773 return resultobj;
52774 fail:
52775 return NULL;
52776 }
52777
52778
52779 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52780 PyObject *resultobj = 0;
52781 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52782 wxPoint *arg2 = 0 ;
52783 wxGBSizerItem *result = 0 ;
52784 void *argp1 = 0 ;
52785 int res1 = 0 ;
52786 wxPoint temp2 ;
52787 PyObject * obj0 = 0 ;
52788 PyObject * obj1 = 0 ;
52789 char * kwnames[] = {
52790 (char *) "self",(char *) "pt", NULL
52791 };
52792
52793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52795 if (!SWIG_IsOK(res1)) {
52796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52797 }
52798 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52799 {
52800 arg2 = &temp2;
52801 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52802 }
52803 {
52804 PyThreadState* __tstate = wxPyBeginAllowThreads();
52805 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52806 wxPyEndAllowThreads(__tstate);
52807 if (PyErr_Occurred()) SWIG_fail;
52808 }
52809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52810 return resultobj;
52811 fail:
52812 return NULL;
52813 }
52814
52815
52816 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52817 PyObject *resultobj = 0;
52818 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52819 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52820 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52821 bool result;
52822 void *argp1 = 0 ;
52823 int res1 = 0 ;
52824 void *argp2 = 0 ;
52825 int res2 = 0 ;
52826 void *argp3 = 0 ;
52827 int res3 = 0 ;
52828 PyObject * obj0 = 0 ;
52829 PyObject * obj1 = 0 ;
52830 PyObject * obj2 = 0 ;
52831 char * kwnames[] = {
52832 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52833 };
52834
52835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52837 if (!SWIG_IsOK(res1)) {
52838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52839 }
52840 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52842 if (!SWIG_IsOK(res2)) {
52843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52844 }
52845 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52846 if (obj2) {
52847 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52848 if (!SWIG_IsOK(res3)) {
52849 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52850 }
52851 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52852 }
52853 {
52854 PyThreadState* __tstate = wxPyBeginAllowThreads();
52855 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52856 wxPyEndAllowThreads(__tstate);
52857 if (PyErr_Occurred()) SWIG_fail;
52858 }
52859 {
52860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52861 }
52862 return resultobj;
52863 fail:
52864 return NULL;
52865 }
52866
52867
52868 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52869 PyObject *resultobj = 0;
52870 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52871 wxGBPosition *arg2 = 0 ;
52872 wxGBSpan *arg3 = 0 ;
52873 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52874 bool result;
52875 void *argp1 = 0 ;
52876 int res1 = 0 ;
52877 wxGBPosition temp2 ;
52878 wxGBSpan temp3 ;
52879 void *argp4 = 0 ;
52880 int res4 = 0 ;
52881 PyObject * obj0 = 0 ;
52882 PyObject * obj1 = 0 ;
52883 PyObject * obj2 = 0 ;
52884 PyObject * obj3 = 0 ;
52885 char * kwnames[] = {
52886 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52887 };
52888
52889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52891 if (!SWIG_IsOK(res1)) {
52892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52893 }
52894 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52895 {
52896 arg2 = &temp2;
52897 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52898 }
52899 {
52900 arg3 = &temp3;
52901 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52902 }
52903 if (obj3) {
52904 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52905 if (!SWIG_IsOK(res4)) {
52906 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52907 }
52908 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52909 }
52910 {
52911 PyThreadState* __tstate = wxPyBeginAllowThreads();
52912 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52913 wxPyEndAllowThreads(__tstate);
52914 if (PyErr_Occurred()) SWIG_fail;
52915 }
52916 {
52917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52918 }
52919 return resultobj;
52920 fail:
52921 return NULL;
52922 }
52923
52924
52925 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52926 PyObject *obj;
52927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52928 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52929 return SWIG_Py_Void();
52930 }
52931
52932 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52933 return SWIG_Python_InitShadowInstance(args);
52934 }
52935
52936 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52937 PyObject *resultobj = 0;
52938 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52939 wxRelationship arg2 ;
52940 wxWindow *arg3 = (wxWindow *) 0 ;
52941 wxEdge arg4 ;
52942 int arg5 = (int) 0 ;
52943 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52944 void *argp1 = 0 ;
52945 int res1 = 0 ;
52946 int val2 ;
52947 int ecode2 = 0 ;
52948 void *argp3 = 0 ;
52949 int res3 = 0 ;
52950 int val4 ;
52951 int ecode4 = 0 ;
52952 int val5 ;
52953 int ecode5 = 0 ;
52954 int val6 ;
52955 int ecode6 = 0 ;
52956 PyObject * obj0 = 0 ;
52957 PyObject * obj1 = 0 ;
52958 PyObject * obj2 = 0 ;
52959 PyObject * obj3 = 0 ;
52960 PyObject * obj4 = 0 ;
52961 PyObject * obj5 = 0 ;
52962 char * kwnames[] = {
52963 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52964 };
52965
52966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52968 if (!SWIG_IsOK(res1)) {
52969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52970 }
52971 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52972 ecode2 = SWIG_AsVal_int(obj1, &val2);
52973 if (!SWIG_IsOK(ecode2)) {
52974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52975 }
52976 arg2 = static_cast< wxRelationship >(val2);
52977 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52978 if (!SWIG_IsOK(res3)) {
52979 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52980 }
52981 arg3 = reinterpret_cast< wxWindow * >(argp3);
52982 ecode4 = SWIG_AsVal_int(obj3, &val4);
52983 if (!SWIG_IsOK(ecode4)) {
52984 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52985 }
52986 arg4 = static_cast< wxEdge >(val4);
52987 if (obj4) {
52988 ecode5 = SWIG_AsVal_int(obj4, &val5);
52989 if (!SWIG_IsOK(ecode5)) {
52990 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52991 }
52992 arg5 = static_cast< int >(val5);
52993 }
52994 if (obj5) {
52995 ecode6 = SWIG_AsVal_int(obj5, &val6);
52996 if (!SWIG_IsOK(ecode6)) {
52997 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52998 }
52999 arg6 = static_cast< int >(val6);
53000 }
53001 {
53002 PyThreadState* __tstate = wxPyBeginAllowThreads();
53003 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
53004 wxPyEndAllowThreads(__tstate);
53005 if (PyErr_Occurred()) SWIG_fail;
53006 }
53007 resultobj = SWIG_Py_Void();
53008 return resultobj;
53009 fail:
53010 return NULL;
53011 }
53012
53013
53014 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53015 PyObject *resultobj = 0;
53016 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53017 wxWindow *arg2 = (wxWindow *) 0 ;
53018 int arg3 = (int) 0 ;
53019 void *argp1 = 0 ;
53020 int res1 = 0 ;
53021 void *argp2 = 0 ;
53022 int res2 = 0 ;
53023 int val3 ;
53024 int ecode3 = 0 ;
53025 PyObject * obj0 = 0 ;
53026 PyObject * obj1 = 0 ;
53027 PyObject * obj2 = 0 ;
53028 char * kwnames[] = {
53029 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53030 };
53031
53032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53034 if (!SWIG_IsOK(res1)) {
53035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53036 }
53037 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53038 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53039 if (!SWIG_IsOK(res2)) {
53040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53041 }
53042 arg2 = reinterpret_cast< wxWindow * >(argp2);
53043 if (obj2) {
53044 ecode3 = SWIG_AsVal_int(obj2, &val3);
53045 if (!SWIG_IsOK(ecode3)) {
53046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
53047 }
53048 arg3 = static_cast< int >(val3);
53049 }
53050 {
53051 PyThreadState* __tstate = wxPyBeginAllowThreads();
53052 (arg1)->LeftOf(arg2,arg3);
53053 wxPyEndAllowThreads(__tstate);
53054 if (PyErr_Occurred()) SWIG_fail;
53055 }
53056 resultobj = SWIG_Py_Void();
53057 return resultobj;
53058 fail:
53059 return NULL;
53060 }
53061
53062
53063 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53064 PyObject *resultobj = 0;
53065 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53066 wxWindow *arg2 = (wxWindow *) 0 ;
53067 int arg3 = (int) 0 ;
53068 void *argp1 = 0 ;
53069 int res1 = 0 ;
53070 void *argp2 = 0 ;
53071 int res2 = 0 ;
53072 int val3 ;
53073 int ecode3 = 0 ;
53074 PyObject * obj0 = 0 ;
53075 PyObject * obj1 = 0 ;
53076 PyObject * obj2 = 0 ;
53077 char * kwnames[] = {
53078 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53079 };
53080
53081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53083 if (!SWIG_IsOK(res1)) {
53084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53085 }
53086 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53088 if (!SWIG_IsOK(res2)) {
53089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53090 }
53091 arg2 = reinterpret_cast< wxWindow * >(argp2);
53092 if (obj2) {
53093 ecode3 = SWIG_AsVal_int(obj2, &val3);
53094 if (!SWIG_IsOK(ecode3)) {
53095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
53096 }
53097 arg3 = static_cast< int >(val3);
53098 }
53099 {
53100 PyThreadState* __tstate = wxPyBeginAllowThreads();
53101 (arg1)->RightOf(arg2,arg3);
53102 wxPyEndAllowThreads(__tstate);
53103 if (PyErr_Occurred()) SWIG_fail;
53104 }
53105 resultobj = SWIG_Py_Void();
53106 return resultobj;
53107 fail:
53108 return NULL;
53109 }
53110
53111
53112 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53113 PyObject *resultobj = 0;
53114 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53115 wxWindow *arg2 = (wxWindow *) 0 ;
53116 int arg3 = (int) 0 ;
53117 void *argp1 = 0 ;
53118 int res1 = 0 ;
53119 void *argp2 = 0 ;
53120 int res2 = 0 ;
53121 int val3 ;
53122 int ecode3 = 0 ;
53123 PyObject * obj0 = 0 ;
53124 PyObject * obj1 = 0 ;
53125 PyObject * obj2 = 0 ;
53126 char * kwnames[] = {
53127 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53128 };
53129
53130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53132 if (!SWIG_IsOK(res1)) {
53133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53134 }
53135 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53137 if (!SWIG_IsOK(res2)) {
53138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
53139 }
53140 arg2 = reinterpret_cast< wxWindow * >(argp2);
53141 if (obj2) {
53142 ecode3 = SWIG_AsVal_int(obj2, &val3);
53143 if (!SWIG_IsOK(ecode3)) {
53144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
53145 }
53146 arg3 = static_cast< int >(val3);
53147 }
53148 {
53149 PyThreadState* __tstate = wxPyBeginAllowThreads();
53150 (arg1)->Above(arg2,arg3);
53151 wxPyEndAllowThreads(__tstate);
53152 if (PyErr_Occurred()) SWIG_fail;
53153 }
53154 resultobj = SWIG_Py_Void();
53155 return resultobj;
53156 fail:
53157 return NULL;
53158 }
53159
53160
53161 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53162 PyObject *resultobj = 0;
53163 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53164 wxWindow *arg2 = (wxWindow *) 0 ;
53165 int arg3 = (int) 0 ;
53166 void *argp1 = 0 ;
53167 int res1 = 0 ;
53168 void *argp2 = 0 ;
53169 int res2 = 0 ;
53170 int val3 ;
53171 int ecode3 = 0 ;
53172 PyObject * obj0 = 0 ;
53173 PyObject * obj1 = 0 ;
53174 PyObject * obj2 = 0 ;
53175 char * kwnames[] = {
53176 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53177 };
53178
53179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53181 if (!SWIG_IsOK(res1)) {
53182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53183 }
53184 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53186 if (!SWIG_IsOK(res2)) {
53187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53188 }
53189 arg2 = reinterpret_cast< wxWindow * >(argp2);
53190 if (obj2) {
53191 ecode3 = SWIG_AsVal_int(obj2, &val3);
53192 if (!SWIG_IsOK(ecode3)) {
53193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53194 }
53195 arg3 = static_cast< int >(val3);
53196 }
53197 {
53198 PyThreadState* __tstate = wxPyBeginAllowThreads();
53199 (arg1)->Below(arg2,arg3);
53200 wxPyEndAllowThreads(__tstate);
53201 if (PyErr_Occurred()) SWIG_fail;
53202 }
53203 resultobj = SWIG_Py_Void();
53204 return resultobj;
53205 fail:
53206 return NULL;
53207 }
53208
53209
53210 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53211 PyObject *resultobj = 0;
53212 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53213 wxWindow *arg2 = (wxWindow *) 0 ;
53214 wxEdge arg3 ;
53215 int arg4 = (int) 0 ;
53216 void *argp1 = 0 ;
53217 int res1 = 0 ;
53218 void *argp2 = 0 ;
53219 int res2 = 0 ;
53220 int val3 ;
53221 int ecode3 = 0 ;
53222 int val4 ;
53223 int ecode4 = 0 ;
53224 PyObject * obj0 = 0 ;
53225 PyObject * obj1 = 0 ;
53226 PyObject * obj2 = 0 ;
53227 PyObject * obj3 = 0 ;
53228 char * kwnames[] = {
53229 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53230 };
53231
53232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53234 if (!SWIG_IsOK(res1)) {
53235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53236 }
53237 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53238 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53239 if (!SWIG_IsOK(res2)) {
53240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53241 }
53242 arg2 = reinterpret_cast< wxWindow * >(argp2);
53243 ecode3 = SWIG_AsVal_int(obj2, &val3);
53244 if (!SWIG_IsOK(ecode3)) {
53245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53246 }
53247 arg3 = static_cast< wxEdge >(val3);
53248 if (obj3) {
53249 ecode4 = SWIG_AsVal_int(obj3, &val4);
53250 if (!SWIG_IsOK(ecode4)) {
53251 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53252 }
53253 arg4 = static_cast< int >(val4);
53254 }
53255 {
53256 PyThreadState* __tstate = wxPyBeginAllowThreads();
53257 (arg1)->SameAs(arg2,arg3,arg4);
53258 wxPyEndAllowThreads(__tstate);
53259 if (PyErr_Occurred()) SWIG_fail;
53260 }
53261 resultobj = SWIG_Py_Void();
53262 return resultobj;
53263 fail:
53264 return NULL;
53265 }
53266
53267
53268 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53269 PyObject *resultobj = 0;
53270 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53271 wxWindow *arg2 = (wxWindow *) 0 ;
53272 wxEdge arg3 ;
53273 int arg4 ;
53274 void *argp1 = 0 ;
53275 int res1 = 0 ;
53276 void *argp2 = 0 ;
53277 int res2 = 0 ;
53278 int val3 ;
53279 int ecode3 = 0 ;
53280 int val4 ;
53281 int ecode4 = 0 ;
53282 PyObject * obj0 = 0 ;
53283 PyObject * obj1 = 0 ;
53284 PyObject * obj2 = 0 ;
53285 PyObject * obj3 = 0 ;
53286 char * kwnames[] = {
53287 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53288 };
53289
53290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53292 if (!SWIG_IsOK(res1)) {
53293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53294 }
53295 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53297 if (!SWIG_IsOK(res2)) {
53298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53299 }
53300 arg2 = reinterpret_cast< wxWindow * >(argp2);
53301 ecode3 = SWIG_AsVal_int(obj2, &val3);
53302 if (!SWIG_IsOK(ecode3)) {
53303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53304 }
53305 arg3 = static_cast< wxEdge >(val3);
53306 ecode4 = SWIG_AsVal_int(obj3, &val4);
53307 if (!SWIG_IsOK(ecode4)) {
53308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53309 }
53310 arg4 = static_cast< int >(val4);
53311 {
53312 PyThreadState* __tstate = wxPyBeginAllowThreads();
53313 (arg1)->PercentOf(arg2,arg3,arg4);
53314 wxPyEndAllowThreads(__tstate);
53315 if (PyErr_Occurred()) SWIG_fail;
53316 }
53317 resultobj = SWIG_Py_Void();
53318 return resultobj;
53319 fail:
53320 return NULL;
53321 }
53322
53323
53324 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53325 PyObject *resultobj = 0;
53326 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53327 int arg2 ;
53328 void *argp1 = 0 ;
53329 int res1 = 0 ;
53330 int val2 ;
53331 int ecode2 = 0 ;
53332 PyObject * obj0 = 0 ;
53333 PyObject * obj1 = 0 ;
53334 char * kwnames[] = {
53335 (char *) "self",(char *) "val", NULL
53336 };
53337
53338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53340 if (!SWIG_IsOK(res1)) {
53341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53342 }
53343 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53344 ecode2 = SWIG_AsVal_int(obj1, &val2);
53345 if (!SWIG_IsOK(ecode2)) {
53346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53347 }
53348 arg2 = static_cast< int >(val2);
53349 {
53350 PyThreadState* __tstate = wxPyBeginAllowThreads();
53351 (arg1)->Absolute(arg2);
53352 wxPyEndAllowThreads(__tstate);
53353 if (PyErr_Occurred()) SWIG_fail;
53354 }
53355 resultobj = SWIG_Py_Void();
53356 return resultobj;
53357 fail:
53358 return NULL;
53359 }
53360
53361
53362 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53363 PyObject *resultobj = 0;
53364 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53365 void *argp1 = 0 ;
53366 int res1 = 0 ;
53367 PyObject *swig_obj[1] ;
53368
53369 if (!args) SWIG_fail;
53370 swig_obj[0] = args;
53371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53372 if (!SWIG_IsOK(res1)) {
53373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53374 }
53375 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53376 {
53377 PyThreadState* __tstate = wxPyBeginAllowThreads();
53378 (arg1)->Unconstrained();
53379 wxPyEndAllowThreads(__tstate);
53380 if (PyErr_Occurred()) SWIG_fail;
53381 }
53382 resultobj = SWIG_Py_Void();
53383 return resultobj;
53384 fail:
53385 return NULL;
53386 }
53387
53388
53389 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53390 PyObject *resultobj = 0;
53391 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53392 void *argp1 = 0 ;
53393 int res1 = 0 ;
53394 PyObject *swig_obj[1] ;
53395
53396 if (!args) SWIG_fail;
53397 swig_obj[0] = args;
53398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53399 if (!SWIG_IsOK(res1)) {
53400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53401 }
53402 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53403 {
53404 PyThreadState* __tstate = wxPyBeginAllowThreads();
53405 (arg1)->AsIs();
53406 wxPyEndAllowThreads(__tstate);
53407 if (PyErr_Occurred()) SWIG_fail;
53408 }
53409 resultobj = SWIG_Py_Void();
53410 return resultobj;
53411 fail:
53412 return NULL;
53413 }
53414
53415
53416 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53417 PyObject *resultobj = 0;
53418 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53419 wxWindow *result = 0 ;
53420 void *argp1 = 0 ;
53421 int res1 = 0 ;
53422 PyObject *swig_obj[1] ;
53423
53424 if (!args) SWIG_fail;
53425 swig_obj[0] = args;
53426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53427 if (!SWIG_IsOK(res1)) {
53428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53429 }
53430 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53431 {
53432 PyThreadState* __tstate = wxPyBeginAllowThreads();
53433 result = (wxWindow *)(arg1)->GetOtherWindow();
53434 wxPyEndAllowThreads(__tstate);
53435 if (PyErr_Occurred()) SWIG_fail;
53436 }
53437 {
53438 resultobj = wxPyMake_wxObject(result, 0);
53439 }
53440 return resultobj;
53441 fail:
53442 return NULL;
53443 }
53444
53445
53446 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53447 PyObject *resultobj = 0;
53448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53449 wxEdge result;
53450 void *argp1 = 0 ;
53451 int res1 = 0 ;
53452 PyObject *swig_obj[1] ;
53453
53454 if (!args) SWIG_fail;
53455 swig_obj[0] = args;
53456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53457 if (!SWIG_IsOK(res1)) {
53458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53459 }
53460 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53461 {
53462 PyThreadState* __tstate = wxPyBeginAllowThreads();
53463 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53464 wxPyEndAllowThreads(__tstate);
53465 if (PyErr_Occurred()) SWIG_fail;
53466 }
53467 resultobj = SWIG_From_int(static_cast< int >(result));
53468 return resultobj;
53469 fail:
53470 return NULL;
53471 }
53472
53473
53474 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53475 PyObject *resultobj = 0;
53476 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53477 wxEdge arg2 ;
53478 void *argp1 = 0 ;
53479 int res1 = 0 ;
53480 int val2 ;
53481 int ecode2 = 0 ;
53482 PyObject * obj0 = 0 ;
53483 PyObject * obj1 = 0 ;
53484 char * kwnames[] = {
53485 (char *) "self",(char *) "which", NULL
53486 };
53487
53488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53490 if (!SWIG_IsOK(res1)) {
53491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53492 }
53493 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53494 ecode2 = SWIG_AsVal_int(obj1, &val2);
53495 if (!SWIG_IsOK(ecode2)) {
53496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53497 }
53498 arg2 = static_cast< wxEdge >(val2);
53499 {
53500 PyThreadState* __tstate = wxPyBeginAllowThreads();
53501 (arg1)->SetEdge(arg2);
53502 wxPyEndAllowThreads(__tstate);
53503 if (PyErr_Occurred()) SWIG_fail;
53504 }
53505 resultobj = SWIG_Py_Void();
53506 return resultobj;
53507 fail:
53508 return NULL;
53509 }
53510
53511
53512 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53513 PyObject *resultobj = 0;
53514 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53515 int arg2 ;
53516 void *argp1 = 0 ;
53517 int res1 = 0 ;
53518 int val2 ;
53519 int ecode2 = 0 ;
53520 PyObject * obj0 = 0 ;
53521 PyObject * obj1 = 0 ;
53522 char * kwnames[] = {
53523 (char *) "self",(char *) "v", NULL
53524 };
53525
53526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53528 if (!SWIG_IsOK(res1)) {
53529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53530 }
53531 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53532 ecode2 = SWIG_AsVal_int(obj1, &val2);
53533 if (!SWIG_IsOK(ecode2)) {
53534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53535 }
53536 arg2 = static_cast< int >(val2);
53537 {
53538 PyThreadState* __tstate = wxPyBeginAllowThreads();
53539 (arg1)->SetValue(arg2);
53540 wxPyEndAllowThreads(__tstate);
53541 if (PyErr_Occurred()) SWIG_fail;
53542 }
53543 resultobj = SWIG_Py_Void();
53544 return resultobj;
53545 fail:
53546 return NULL;
53547 }
53548
53549
53550 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53551 PyObject *resultobj = 0;
53552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53553 int result;
53554 void *argp1 = 0 ;
53555 int res1 = 0 ;
53556 PyObject *swig_obj[1] ;
53557
53558 if (!args) SWIG_fail;
53559 swig_obj[0] = args;
53560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53561 if (!SWIG_IsOK(res1)) {
53562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53563 }
53564 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53565 {
53566 PyThreadState* __tstate = wxPyBeginAllowThreads();
53567 result = (int)(arg1)->GetMargin();
53568 wxPyEndAllowThreads(__tstate);
53569 if (PyErr_Occurred()) SWIG_fail;
53570 }
53571 resultobj = SWIG_From_int(static_cast< int >(result));
53572 return resultobj;
53573 fail:
53574 return NULL;
53575 }
53576
53577
53578 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53579 PyObject *resultobj = 0;
53580 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53581 int arg2 ;
53582 void *argp1 = 0 ;
53583 int res1 = 0 ;
53584 int val2 ;
53585 int ecode2 = 0 ;
53586 PyObject * obj0 = 0 ;
53587 PyObject * obj1 = 0 ;
53588 char * kwnames[] = {
53589 (char *) "self",(char *) "m", NULL
53590 };
53591
53592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53594 if (!SWIG_IsOK(res1)) {
53595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53596 }
53597 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53598 ecode2 = SWIG_AsVal_int(obj1, &val2);
53599 if (!SWIG_IsOK(ecode2)) {
53600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53601 }
53602 arg2 = static_cast< int >(val2);
53603 {
53604 PyThreadState* __tstate = wxPyBeginAllowThreads();
53605 (arg1)->SetMargin(arg2);
53606 wxPyEndAllowThreads(__tstate);
53607 if (PyErr_Occurred()) SWIG_fail;
53608 }
53609 resultobj = SWIG_Py_Void();
53610 return resultobj;
53611 fail:
53612 return NULL;
53613 }
53614
53615
53616 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53617 PyObject *resultobj = 0;
53618 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53619 int result;
53620 void *argp1 = 0 ;
53621 int res1 = 0 ;
53622 PyObject *swig_obj[1] ;
53623
53624 if (!args) SWIG_fail;
53625 swig_obj[0] = args;
53626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53627 if (!SWIG_IsOK(res1)) {
53628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53629 }
53630 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53631 {
53632 PyThreadState* __tstate = wxPyBeginAllowThreads();
53633 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53634 wxPyEndAllowThreads(__tstate);
53635 if (PyErr_Occurred()) SWIG_fail;
53636 }
53637 resultobj = SWIG_From_int(static_cast< int >(result));
53638 return resultobj;
53639 fail:
53640 return NULL;
53641 }
53642
53643
53644 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53645 PyObject *resultobj = 0;
53646 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53647 int result;
53648 void *argp1 = 0 ;
53649 int res1 = 0 ;
53650 PyObject *swig_obj[1] ;
53651
53652 if (!args) SWIG_fail;
53653 swig_obj[0] = args;
53654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53655 if (!SWIG_IsOK(res1)) {
53656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53657 }
53658 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53659 {
53660 PyThreadState* __tstate = wxPyBeginAllowThreads();
53661 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53662 wxPyEndAllowThreads(__tstate);
53663 if (PyErr_Occurred()) SWIG_fail;
53664 }
53665 resultobj = SWIG_From_int(static_cast< int >(result));
53666 return resultobj;
53667 fail:
53668 return NULL;
53669 }
53670
53671
53672 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53673 PyObject *resultobj = 0;
53674 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53675 int result;
53676 void *argp1 = 0 ;
53677 int res1 = 0 ;
53678 PyObject *swig_obj[1] ;
53679
53680 if (!args) SWIG_fail;
53681 swig_obj[0] = args;
53682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53683 if (!SWIG_IsOK(res1)) {
53684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53685 }
53686 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53687 {
53688 PyThreadState* __tstate = wxPyBeginAllowThreads();
53689 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53690 wxPyEndAllowThreads(__tstate);
53691 if (PyErr_Occurred()) SWIG_fail;
53692 }
53693 resultobj = SWIG_From_int(static_cast< int >(result));
53694 return resultobj;
53695 fail:
53696 return NULL;
53697 }
53698
53699
53700 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53701 PyObject *resultobj = 0;
53702 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53703 bool result;
53704 void *argp1 = 0 ;
53705 int res1 = 0 ;
53706 PyObject *swig_obj[1] ;
53707
53708 if (!args) SWIG_fail;
53709 swig_obj[0] = args;
53710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53711 if (!SWIG_IsOK(res1)) {
53712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53713 }
53714 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53715 {
53716 PyThreadState* __tstate = wxPyBeginAllowThreads();
53717 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53718 wxPyEndAllowThreads(__tstate);
53719 if (PyErr_Occurred()) SWIG_fail;
53720 }
53721 {
53722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53723 }
53724 return resultobj;
53725 fail:
53726 return NULL;
53727 }
53728
53729
53730 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53731 PyObject *resultobj = 0;
53732 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53733 bool arg2 ;
53734 void *argp1 = 0 ;
53735 int res1 = 0 ;
53736 bool val2 ;
53737 int ecode2 = 0 ;
53738 PyObject * obj0 = 0 ;
53739 PyObject * obj1 = 0 ;
53740 char * kwnames[] = {
53741 (char *) "self",(char *) "d", NULL
53742 };
53743
53744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53746 if (!SWIG_IsOK(res1)) {
53747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53748 }
53749 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53750 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53751 if (!SWIG_IsOK(ecode2)) {
53752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53753 }
53754 arg2 = static_cast< bool >(val2);
53755 {
53756 PyThreadState* __tstate = wxPyBeginAllowThreads();
53757 (arg1)->SetDone(arg2);
53758 wxPyEndAllowThreads(__tstate);
53759 if (PyErr_Occurred()) SWIG_fail;
53760 }
53761 resultobj = SWIG_Py_Void();
53762 return resultobj;
53763 fail:
53764 return NULL;
53765 }
53766
53767
53768 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53769 PyObject *resultobj = 0;
53770 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53771 wxRelationship result;
53772 void *argp1 = 0 ;
53773 int res1 = 0 ;
53774 PyObject *swig_obj[1] ;
53775
53776 if (!args) SWIG_fail;
53777 swig_obj[0] = args;
53778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53779 if (!SWIG_IsOK(res1)) {
53780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53781 }
53782 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53783 {
53784 PyThreadState* __tstate = wxPyBeginAllowThreads();
53785 result = (wxRelationship)(arg1)->GetRelationship();
53786 wxPyEndAllowThreads(__tstate);
53787 if (PyErr_Occurred()) SWIG_fail;
53788 }
53789 resultobj = SWIG_From_int(static_cast< int >(result));
53790 return resultobj;
53791 fail:
53792 return NULL;
53793 }
53794
53795
53796 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53797 PyObject *resultobj = 0;
53798 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53799 wxRelationship arg2 ;
53800 void *argp1 = 0 ;
53801 int res1 = 0 ;
53802 int val2 ;
53803 int ecode2 = 0 ;
53804 PyObject * obj0 = 0 ;
53805 PyObject * obj1 = 0 ;
53806 char * kwnames[] = {
53807 (char *) "self",(char *) "r", NULL
53808 };
53809
53810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53812 if (!SWIG_IsOK(res1)) {
53813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53814 }
53815 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53816 ecode2 = SWIG_AsVal_int(obj1, &val2);
53817 if (!SWIG_IsOK(ecode2)) {
53818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53819 }
53820 arg2 = static_cast< wxRelationship >(val2);
53821 {
53822 PyThreadState* __tstate = wxPyBeginAllowThreads();
53823 (arg1)->SetRelationship(arg2);
53824 wxPyEndAllowThreads(__tstate);
53825 if (PyErr_Occurred()) SWIG_fail;
53826 }
53827 resultobj = SWIG_Py_Void();
53828 return resultobj;
53829 fail:
53830 return NULL;
53831 }
53832
53833
53834 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53835 PyObject *resultobj = 0;
53836 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53837 wxWindow *arg2 = (wxWindow *) 0 ;
53838 bool result;
53839 void *argp1 = 0 ;
53840 int res1 = 0 ;
53841 void *argp2 = 0 ;
53842 int res2 = 0 ;
53843 PyObject * obj0 = 0 ;
53844 PyObject * obj1 = 0 ;
53845 char * kwnames[] = {
53846 (char *) "self",(char *) "otherW", NULL
53847 };
53848
53849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53851 if (!SWIG_IsOK(res1)) {
53852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53853 }
53854 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53856 if (!SWIG_IsOK(res2)) {
53857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53858 }
53859 arg2 = reinterpret_cast< wxWindow * >(argp2);
53860 {
53861 PyThreadState* __tstate = wxPyBeginAllowThreads();
53862 result = (bool)(arg1)->ResetIfWin(arg2);
53863 wxPyEndAllowThreads(__tstate);
53864 if (PyErr_Occurred()) SWIG_fail;
53865 }
53866 {
53867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53868 }
53869 return resultobj;
53870 fail:
53871 return NULL;
53872 }
53873
53874
53875 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53876 PyObject *resultobj = 0;
53877 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53878 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53879 wxWindow *arg3 = (wxWindow *) 0 ;
53880 bool result;
53881 void *argp1 = 0 ;
53882 int res1 = 0 ;
53883 void *argp2 = 0 ;
53884 int res2 = 0 ;
53885 void *argp3 = 0 ;
53886 int res3 = 0 ;
53887 PyObject * obj0 = 0 ;
53888 PyObject * obj1 = 0 ;
53889 PyObject * obj2 = 0 ;
53890 char * kwnames[] = {
53891 (char *) "self",(char *) "constraints",(char *) "win", NULL
53892 };
53893
53894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53896 if (!SWIG_IsOK(res1)) {
53897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53898 }
53899 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53900 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53901 if (!SWIG_IsOK(res2)) {
53902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53903 }
53904 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53905 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53906 if (!SWIG_IsOK(res3)) {
53907 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53908 }
53909 arg3 = reinterpret_cast< wxWindow * >(argp3);
53910 {
53911 PyThreadState* __tstate = wxPyBeginAllowThreads();
53912 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53913 wxPyEndAllowThreads(__tstate);
53914 if (PyErr_Occurred()) SWIG_fail;
53915 }
53916 {
53917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53918 }
53919 return resultobj;
53920 fail:
53921 return NULL;
53922 }
53923
53924
53925 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53926 PyObject *resultobj = 0;
53927 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53928 wxEdge arg2 ;
53929 wxWindow *arg3 = (wxWindow *) 0 ;
53930 wxWindow *arg4 = (wxWindow *) 0 ;
53931 int result;
53932 void *argp1 = 0 ;
53933 int res1 = 0 ;
53934 int val2 ;
53935 int ecode2 = 0 ;
53936 void *argp3 = 0 ;
53937 int res3 = 0 ;
53938 void *argp4 = 0 ;
53939 int res4 = 0 ;
53940 PyObject * obj0 = 0 ;
53941 PyObject * obj1 = 0 ;
53942 PyObject * obj2 = 0 ;
53943 PyObject * obj3 = 0 ;
53944 char * kwnames[] = {
53945 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53946 };
53947
53948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53950 if (!SWIG_IsOK(res1)) {
53951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53952 }
53953 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53954 ecode2 = SWIG_AsVal_int(obj1, &val2);
53955 if (!SWIG_IsOK(ecode2)) {
53956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53957 }
53958 arg2 = static_cast< wxEdge >(val2);
53959 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53960 if (!SWIG_IsOK(res3)) {
53961 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53962 }
53963 arg3 = reinterpret_cast< wxWindow * >(argp3);
53964 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53965 if (!SWIG_IsOK(res4)) {
53966 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53967 }
53968 arg4 = reinterpret_cast< wxWindow * >(argp4);
53969 {
53970 PyThreadState* __tstate = wxPyBeginAllowThreads();
53971 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53972 wxPyEndAllowThreads(__tstate);
53973 if (PyErr_Occurred()) SWIG_fail;
53974 }
53975 resultobj = SWIG_From_int(static_cast< int >(result));
53976 return resultobj;
53977 fail:
53978 return NULL;
53979 }
53980
53981
53982 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53983 PyObject *obj;
53984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53985 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53986 return SWIG_Py_Void();
53987 }
53988
53989 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53990 PyObject *resultobj = 0;
53991 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53992 wxIndividualLayoutConstraint *result = 0 ;
53993 void *argp1 = 0 ;
53994 int res1 = 0 ;
53995 PyObject *swig_obj[1] ;
53996
53997 if (!args) SWIG_fail;
53998 swig_obj[0] = args;
53999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54000 if (!SWIG_IsOK(res1)) {
54001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54002 }
54003 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54004 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
54005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54006 return resultobj;
54007 fail:
54008 return NULL;
54009 }
54010
54011
54012 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54013 PyObject *resultobj = 0;
54014 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54015 wxIndividualLayoutConstraint *result = 0 ;
54016 void *argp1 = 0 ;
54017 int res1 = 0 ;
54018 PyObject *swig_obj[1] ;
54019
54020 if (!args) SWIG_fail;
54021 swig_obj[0] = args;
54022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54023 if (!SWIG_IsOK(res1)) {
54024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54025 }
54026 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54027 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
54028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54029 return resultobj;
54030 fail:
54031 return NULL;
54032 }
54033
54034
54035 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54036 PyObject *resultobj = 0;
54037 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54038 wxIndividualLayoutConstraint *result = 0 ;
54039 void *argp1 = 0 ;
54040 int res1 = 0 ;
54041 PyObject *swig_obj[1] ;
54042
54043 if (!args) SWIG_fail;
54044 swig_obj[0] = args;
54045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54046 if (!SWIG_IsOK(res1)) {
54047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54048 }
54049 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54050 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
54051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54052 return resultobj;
54053 fail:
54054 return NULL;
54055 }
54056
54057
54058 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54059 PyObject *resultobj = 0;
54060 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54061 wxIndividualLayoutConstraint *result = 0 ;
54062 void *argp1 = 0 ;
54063 int res1 = 0 ;
54064 PyObject *swig_obj[1] ;
54065
54066 if (!args) SWIG_fail;
54067 swig_obj[0] = args;
54068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54069 if (!SWIG_IsOK(res1)) {
54070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54071 }
54072 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54073 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
54074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54075 return resultobj;
54076 fail:
54077 return NULL;
54078 }
54079
54080
54081 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54082 PyObject *resultobj = 0;
54083 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54084 wxIndividualLayoutConstraint *result = 0 ;
54085 void *argp1 = 0 ;
54086 int res1 = 0 ;
54087 PyObject *swig_obj[1] ;
54088
54089 if (!args) SWIG_fail;
54090 swig_obj[0] = args;
54091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54092 if (!SWIG_IsOK(res1)) {
54093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54094 }
54095 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54096 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
54097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54098 return resultobj;
54099 fail:
54100 return NULL;
54101 }
54102
54103
54104 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54105 PyObject *resultobj = 0;
54106 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54107 wxIndividualLayoutConstraint *result = 0 ;
54108 void *argp1 = 0 ;
54109 int res1 = 0 ;
54110 PyObject *swig_obj[1] ;
54111
54112 if (!args) SWIG_fail;
54113 swig_obj[0] = args;
54114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54115 if (!SWIG_IsOK(res1)) {
54116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54117 }
54118 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54119 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
54120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54121 return resultobj;
54122 fail:
54123 return NULL;
54124 }
54125
54126
54127 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54128 PyObject *resultobj = 0;
54129 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54130 wxIndividualLayoutConstraint *result = 0 ;
54131 void *argp1 = 0 ;
54132 int res1 = 0 ;
54133 PyObject *swig_obj[1] ;
54134
54135 if (!args) SWIG_fail;
54136 swig_obj[0] = args;
54137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54138 if (!SWIG_IsOK(res1)) {
54139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54140 }
54141 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54142 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
54143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54144 return resultobj;
54145 fail:
54146 return NULL;
54147 }
54148
54149
54150 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54151 PyObject *resultobj = 0;
54152 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54153 wxIndividualLayoutConstraint *result = 0 ;
54154 void *argp1 = 0 ;
54155 int res1 = 0 ;
54156 PyObject *swig_obj[1] ;
54157
54158 if (!args) SWIG_fail;
54159 swig_obj[0] = args;
54160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54161 if (!SWIG_IsOK(res1)) {
54162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54163 }
54164 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54165 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54167 return resultobj;
54168 fail:
54169 return NULL;
54170 }
54171
54172
54173 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54174 PyObject *resultobj = 0;
54175 wxLayoutConstraints *result = 0 ;
54176
54177 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54178 {
54179 PyThreadState* __tstate = wxPyBeginAllowThreads();
54180 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54181 wxPyEndAllowThreads(__tstate);
54182 if (PyErr_Occurred()) SWIG_fail;
54183 }
54184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54185 return resultobj;
54186 fail:
54187 return NULL;
54188 }
54189
54190
54191 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54192 PyObject *resultobj = 0;
54193 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54194 void *argp1 = 0 ;
54195 int res1 = 0 ;
54196 PyObject *swig_obj[1] ;
54197
54198 if (!args) SWIG_fail;
54199 swig_obj[0] = args;
54200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54201 if (!SWIG_IsOK(res1)) {
54202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54203 }
54204 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54205 {
54206 PyThreadState* __tstate = wxPyBeginAllowThreads();
54207 delete arg1;
54208
54209 wxPyEndAllowThreads(__tstate);
54210 if (PyErr_Occurred()) SWIG_fail;
54211 }
54212 resultobj = SWIG_Py_Void();
54213 return resultobj;
54214 fail:
54215 return NULL;
54216 }
54217
54218
54219 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54220 PyObject *resultobj = 0;
54221 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54222 wxWindow *arg2 = (wxWindow *) 0 ;
54223 int *arg3 = (int *) 0 ;
54224 bool result;
54225 void *argp1 = 0 ;
54226 int res1 = 0 ;
54227 void *argp2 = 0 ;
54228 int res2 = 0 ;
54229 int temp3 ;
54230 int res3 = SWIG_TMPOBJ ;
54231 PyObject * obj0 = 0 ;
54232 PyObject * obj1 = 0 ;
54233 char * kwnames[] = {
54234 (char *) "self",(char *) "win", NULL
54235 };
54236
54237 arg3 = &temp3;
54238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54240 if (!SWIG_IsOK(res1)) {
54241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54242 }
54243 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54245 if (!SWIG_IsOK(res2)) {
54246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54247 }
54248 arg2 = reinterpret_cast< wxWindow * >(argp2);
54249 {
54250 PyThreadState* __tstate = wxPyBeginAllowThreads();
54251 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54252 wxPyEndAllowThreads(__tstate);
54253 if (PyErr_Occurred()) SWIG_fail;
54254 }
54255 {
54256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54257 }
54258 if (SWIG_IsTmpObj(res3)) {
54259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54260 } else {
54261 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54263 }
54264 return resultobj;
54265 fail:
54266 return NULL;
54267 }
54268
54269
54270 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54271 PyObject *resultobj = 0;
54272 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54273 bool result;
54274 void *argp1 = 0 ;
54275 int res1 = 0 ;
54276 PyObject *swig_obj[1] ;
54277
54278 if (!args) SWIG_fail;
54279 swig_obj[0] = args;
54280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54281 if (!SWIG_IsOK(res1)) {
54282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54283 }
54284 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54285 {
54286 PyThreadState* __tstate = wxPyBeginAllowThreads();
54287 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54288 wxPyEndAllowThreads(__tstate);
54289 if (PyErr_Occurred()) SWIG_fail;
54290 }
54291 {
54292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54293 }
54294 return resultobj;
54295 fail:
54296 return NULL;
54297 }
54298
54299
54300 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54301 PyObject *obj;
54302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54303 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54304 return SWIG_Py_Void();
54305 }
54306
54307 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54308 return SWIG_Python_InitShadowInstance(args);
54309 }
54310
54311 static PyMethodDef SwigMethods[] = {
54312 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54313 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54314 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54315 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54316 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54317 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54318 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54319 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54320 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54321 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54322 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54323 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54324 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54325 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54335 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54336 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54337 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54339 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54340 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54341 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54342 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54343 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54344 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54345 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54347 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54351 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54353 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54354 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54355 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54356 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54357 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54358 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54359 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54361 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54369 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54370 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54371 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54376 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54377 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54379 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54381 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54383 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54385 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54387 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54389 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54390 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54392 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54394 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54396 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54398 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54399 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54400 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54401 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54405 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54407 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54410 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54411 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54412 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54421 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54422 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54423 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54424 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54425 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54426 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54427 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54428 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54430 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54431 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54432 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
54437 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54438 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54439 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54440 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54441 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54446 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54448 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54455 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54456 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54457 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54458 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54460 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54461 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54462 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54464 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54465 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54466 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54467 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54472 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54473 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54474 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54475 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54476 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54477 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54480 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54481 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54482 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54484 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54485 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54487 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54488 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54489 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54490 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54491 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54492 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54493 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54494 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54495 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54496 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54497 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54498 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54503 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54504 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54509 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54510 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54511 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54512 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54514 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54517 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54518 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54519 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54520 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54523 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54524 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54525 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54528 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54529 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54530 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54531 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54532 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54533 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54534 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54535 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54536 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54538 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54539 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54540 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54542 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54543 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54544 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54545 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54546 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54547 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54548 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54549 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54550 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54551 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54552 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54553 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54554 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54555 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54556 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54557 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54558 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54559 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54561 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54562 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54563 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54564 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54565 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54566 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54567 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54568 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54569 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54570 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54572 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54573 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54574 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54575 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54576 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54577 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54578 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54579 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54581 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54582 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54583 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54584 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54585 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54586 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54587 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54588 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54590 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54591 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54599 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54614 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54615 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54616 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54617 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54620 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54621 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54622 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54626 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
54632 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54633 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54634 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54635 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54638 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54640 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54642 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54644 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54646 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54649 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54650 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54651 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54652 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54653 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54654 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54655 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54656 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54659 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54660 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54661 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54662 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54663 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54664 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54665 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54666 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54667 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54668 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54671 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54672 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54673 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54674 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54675 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54676 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54677 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54678 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54679 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54680 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54681 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54682 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54683 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54684 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54685 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54686 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54687 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54688 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54689 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54690 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54691 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54692 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54693 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54694 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54695 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54696 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54697 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54698 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54699 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54700 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54701 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54702 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54703 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54704 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54705 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54706 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54707 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54708 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54709 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54710 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54711 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54712 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54713 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54714 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54715 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54716 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54717 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54718 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54721 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54722 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54725 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
54727 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
54728 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54731 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54732 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54733 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54734 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54735 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54737 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54738 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54739 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54740 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54742 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54743 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54744 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54746 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54747 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54748 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54750 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54751 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54753 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54754 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54755 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54757 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54758 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54759 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54761 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54763 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54764 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54765 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54767 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54768 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54769 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54770 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54772 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54773 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54774 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54776 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54777 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54778 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54779 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54780 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54782 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54783 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54784 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54786 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54787 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54789 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54790 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54793 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54794 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54795 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54796 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54798 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54799 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54802 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54803 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54804 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54805 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54806 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54807 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54808 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54809 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54810 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54811 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54812 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54813 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54814 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54815 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54816 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54817 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54818 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54819 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54820 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54821 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54822 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54823 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54824 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54825 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54826 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54827 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54828 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54829 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54830 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54831 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54832 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54833 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54834 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54835 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54836 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54837 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54838 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54839 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54840 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54841 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54842 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54843 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54844 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54845 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54846 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54847 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54848 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54849 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54850 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54851 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54852 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54853 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54854 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54855 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54856 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54857 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54858 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54860 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54861 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54862 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54863 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54864 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54865 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54866 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54868 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54869 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54870 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54871 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54872 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54873 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54874 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54875 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54876 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54878 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54879 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54880 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54881 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54882 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54883 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54884 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54885 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54886 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54887 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54888 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54889 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54890 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54891 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54892 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54893 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54894 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54895 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54896 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54897 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54898 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54899 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54900 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54901 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54902 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54903 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54904 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54905 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54907 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54908 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54909 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54911 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54912 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54913 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54914 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54915 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54916 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54917 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54918 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54919 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54921 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54922 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54923 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54924 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54925 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54926 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54927 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54928 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54929 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54931 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54932 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54933 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54934 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54935 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54937 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54938 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54939 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54940 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54941 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54942 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54944 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54945 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54946 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54947 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54948 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54949 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54950 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54951 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54952 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54953 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54954 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54955 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54956 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54957 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54958 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54959 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54960 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54961 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54962 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54963 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54964 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54967 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54968 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54969 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54971 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54972 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54973 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54975 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54976 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54977 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54978 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54979 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54980 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54981 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54982 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54983 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54984 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54985 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54986 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54987 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54988 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54989 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54991 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54992 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54993 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54994 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54995 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54997 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54999 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
55000 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
55001 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
55002 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
55003 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
55004 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55005 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
55006 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
55007 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
55008 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55009 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
55010 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
55011 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
55012 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
55013 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
55014 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55016 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
55017 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
55018 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
55019 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
55022 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
55023 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
55024 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
55025 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
55026 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
55028 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
55030 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
55033 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
55035 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
55036 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
55038 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
55039 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
55040 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
55042 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
55043 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
55044 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55045 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
55046 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
55048 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
55049 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
55050 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
55052 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55053 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
55054 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
55056 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
55057 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
55059 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
55060 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
55062 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
55064 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
55065 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
55066 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
55068 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55069 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
55070 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
55071 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
55072 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
55074 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
55076 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
55077 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
55078 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
55079 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55080 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
55081 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
55083 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
55085 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
55087 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
55088 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
55090 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
55091 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
55092 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
55093 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
55094 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
55095 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
55096 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
55097 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
55098 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
55100 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55101 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
55102 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
55103 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
55104 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
55105 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
55106 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
55107 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
55108 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
55110 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
55111 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
55112 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
55113 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
55114 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
55115 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55117 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
55120 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
55121 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
55122 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
55123 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
55124 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
55125 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
55126 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
55127 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
55128 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
55129 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
55130 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55131 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
55132 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
55133 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
55135 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
55136 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
55137 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
55138 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
55139 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
55140 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
55141 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
55142 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
55143 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
55145 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
55146 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
55147 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
55148 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
55149 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
55150 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
55151 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
55152 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55154 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
55155 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
55156 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
55157 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
55158 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
55159 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
55161 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
55162 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
55164 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
55165 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
55166 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
55167 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55168 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55169 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55170 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55171 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55172 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55173 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55174 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55175 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55176 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55177 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55178 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55180 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55183 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55184 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55185 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55187 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55189 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55190 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55191 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55192 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55193 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55194 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55197 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55198 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55200 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55201 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55202 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55203 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55204 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55206 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55207 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55208 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55209 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55210 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55212 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55213 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55214 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55215 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55216 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55217 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55218 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55219 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55220 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55221 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55222 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55223 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55224 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55225 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55226 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55227 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55228 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55229 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55230 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55231 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55232 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55233 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55234 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55235 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55236 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55237 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55238 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55239 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55240 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55241 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55242 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55243 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55244 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55245 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55247 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55248 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55249 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55250 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55251 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55252 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55253 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55254 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55255 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55256 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55257 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55258 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55259 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55261 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55262 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55263 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55264 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55265 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55266 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55267 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55268 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55269 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55270 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55271 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55272 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55275 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55276 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55277 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55278 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55281 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55282 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55284 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55285 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55287 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55288 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55289 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55290 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55291 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55292 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55293 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55294 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55295 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55296 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55297 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55299 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55300 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55301 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55303 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55304 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55305 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55306 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55307 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55308 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55309 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55310 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55311 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55312 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55313 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55314 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55315 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55316 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55317 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55318 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
55319 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55320 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55321 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55323 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55325 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55326 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55328 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55329 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55330 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55331 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55332 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55333 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55334 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55335 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55336 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55337 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55338 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55339 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55340 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55341 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55342 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55343 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55344 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55345 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55346 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55347 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55348 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55349 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55350 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55351 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55352 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55353 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55354 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55355 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55356 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55357 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55358 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55359 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55360 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55361 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55362 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
55363 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55364 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55365 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55366 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55367 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55368 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55369 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55370 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55371 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55372 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55373 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55374 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55375 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55376 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55377 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55378 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55379 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55380 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55381 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55382 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55383 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55384 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55385 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55386 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55387 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55388 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55389 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55390 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55391 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55392 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55393 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55394 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55395 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55396 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55397 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55398 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55399 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55400 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55401 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55402 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55403 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55404 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55405 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55406 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55407 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55408 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55409 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55410 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55411 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55412 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55413 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55414 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55415 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55416 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55417 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55418 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55419 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55420 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55421 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55422 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55423 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55424 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55425 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55426 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55427 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55428 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55430 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55431 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55432 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55433 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55434 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55435 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55436 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55438 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55439 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55440 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55441 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55442 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55443 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55444 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55445 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55446 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55447 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55448 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55449 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55450 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55451 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55452 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55453 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55454 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55455 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55456 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55457 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55458 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55459 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55460 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55461 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55462 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55465 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55466 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55467 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55468 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55469 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55470 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55471 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55472 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55473 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55474 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55475 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55476 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55477 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55478 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55479 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55480 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55481 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55482 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55483 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55484 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55485 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55486 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55487 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55488 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55489 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55490 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55491 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55492 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55493 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55494 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55495 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55496 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55497 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55498 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55499 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55500 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55501 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55502 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55503 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55504 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55505 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55506 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55507 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55508 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55509 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55510 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55511 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55512 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55513 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55514 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55515 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55516 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55517 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55518 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55519 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55520 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55521 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55522 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55523 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55524 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55525 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55526 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55527 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55528 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55529 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55530 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55531 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55532 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55533 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55534 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55535 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55536 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55537 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55538 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55539 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55540 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55541 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55542 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55543 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55544 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55545 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55547 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55548 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55549 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55550 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55551 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55552 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55553 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55554 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55555 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55556 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55557 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55558 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55559 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55560 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55561 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55562 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55563 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55564 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55565 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55566 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55567 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55568 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55569 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55570 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55571 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55572 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55573 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55574 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55575 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55576 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55577 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55578 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55579 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55580 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55581 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55582 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55583 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55584 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55585 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55586 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55587 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55588 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55589 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55590 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55591 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55592 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55593 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55594 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55595 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55596 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55597 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55598 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55599 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55600 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55601 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55602 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55603 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55604 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55605 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55606 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55607 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55608 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55609 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55610 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55611 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55612 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55613 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55614 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55615 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55616 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55617 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55618 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55619 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55620 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55621 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55622 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55623 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55624 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55625 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55626 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55627 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55628 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55629 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55630 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55631 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55632 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55633 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55634 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55635 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55636 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55637 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55638 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55639 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55640 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55641 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55642 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55643 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55644 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55645 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55646 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55647 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55648 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55649 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55650 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55651 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55652 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55653 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55654 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55655 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55656 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55657 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55658 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55659 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55660 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55661 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55662 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55663 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55664 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55665 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55666 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55667 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55668 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55669 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55670 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55671 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55672 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55673 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55674 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55675 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55676 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55677 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55678 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55679 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55680 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55681 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55682 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55683 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55684 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55685 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55686 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55687 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55688 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55689 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55690 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55691 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55692 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55693 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55694 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55695 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55696 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55697 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55698 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55699 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55700 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55701 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55702 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55703 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55704 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55705 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55706 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55707 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55708 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55709 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55710 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55711 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55712 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55713 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55714 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55715 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55716 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55717 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55718 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55719 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55720 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55721 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55722 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55723 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55724 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55725 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55726 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55727 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55728 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55729 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55730 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55731 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55732 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55733 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55734 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55735 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55736 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55737 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55738 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55739 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55740 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55741 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55742 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55743 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55744 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55745 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55746 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55747 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55748 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55749 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55750 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55751 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55752 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55753 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55754 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55755 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55756 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55757 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55758 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55759 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55760 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55761 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55762 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55763 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55764 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55765 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55766 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55767 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55768 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55769 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55770 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55771 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55772 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55773 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55774 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55775 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55776 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55777 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55778 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55779 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55780 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55781 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55782 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55783 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55784 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55785 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55786 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55787 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55788 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55789 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55790 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55791 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55792 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55793 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55794 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55795 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55796 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55797 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55798 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55799 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55800 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55801 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55802 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55803 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55804 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55805 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55806 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55807 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55808 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55809 { NULL, NULL, 0, NULL }
55810 };
55811
55812
55813 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55814
55815 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55816 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55817 }
55818 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55819 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55820 }
55821 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55822 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55823 }
55824 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55825 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55826 }
55827 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55828 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55829 }
55830 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55831 return (void *)((wxSizer *) ((wxGridSizer *) x));
55832 }
55833 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55834 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55835 }
55836 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55837 return (void *)((wxSizer *) ((wxPySizer *) x));
55838 }
55839 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55840 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55841 }
55842 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55843 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55844 }
55845 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55846 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55847 }
55848 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55849 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55850 }
55851 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55852 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55853 }
55854 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55855 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55856 }
55857 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55858 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55859 }
55860 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55861 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55862 }
55863 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55864 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55865 }
55866 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55867 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55868 }
55869 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55870 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55871 }
55872 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55873 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55874 }
55875 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55876 return (void *)((wxEvent *) ((wxPyEvent *) x));
55877 }
55878 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55879 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55880 }
55881 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55882 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55883 }
55884 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55885 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55886 }
55887 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55888 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55889 }
55890 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55891 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55892 }
55893 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55894 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55895 }
55896 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55897 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55898 }
55899 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55900 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55901 }
55902 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55903 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55904 }
55905 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55906 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55907 }
55908 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55909 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55910 }
55911 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55912 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55913 }
55914 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55915 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55916 }
55917 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55918 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55919 }
55920 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55921 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55922 }
55923 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55924 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55925 }
55926 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55927 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55928 }
55929 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55930 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55931 }
55932 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55933 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55934 }
55935 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55936 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55937 }
55938 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55939 return (void *)((wxEvent *) ((wxShowEvent *) x));
55940 }
55941 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55942 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55943 }
55944 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55945 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55946 }
55947 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55948 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55949 }
55950 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55951 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55952 }
55953 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55954 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55955 }
55956 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55957 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55958 }
55959 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55960 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55961 }
55962 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55963 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55964 }
55965 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55966 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55967 }
55968 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55969 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55970 }
55971 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55972 return (void *)((wxControl *) ((wxControlWithItems *) x));
55973 }
55974 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55975 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55976 }
55977 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55978 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55979 }
55980 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55981 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55982 }
55983 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55984 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55985 }
55986 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55987 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55988 }
55989 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55990 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55991 }
55992 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55993 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55994 }
55995 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55996 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55997 }
55998 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55999 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
56000 }
56001 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
56002 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
56003 }
56004 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
56005 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
56006 }
56007 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
56008 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
56009 }
56010 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
56011 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
56012 }
56013 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
56014 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56015 }
56016 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
56017 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
56018 }
56019 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
56020 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
56021 }
56022 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
56023 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
56024 }
56025 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
56026 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56027 }
56028 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
56029 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56030 }
56031 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
56032 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
56033 }
56034 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
56035 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
56036 }
56037 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
56038 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
56039 }
56040 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
56041 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
56042 }
56043 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
56044 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
56045 }
56046 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
56047 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
56048 }
56049 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
56050 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
56051 }
56052 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
56053 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
56054 }
56055 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
56056 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
56057 }
56058 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
56059 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
56060 }
56061 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
56062 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
56063 }
56064 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
56065 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
56066 }
56067 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
56068 return (void *)((wxObject *) ((wxSizerItem *) x));
56069 }
56070 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
56071 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
56072 }
56073 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
56074 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
56075 }
56076 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
56077 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
56078 }
56079 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
56080 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
56081 }
56082 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
56083 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
56084 }
56085 static void *_p_wxSizerTo_p_wxObject(void *x) {
56086 return (void *)((wxObject *) ((wxSizer *) x));
56087 }
56088 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
56089 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
56090 }
56091 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
56092 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
56093 }
56094 static void *_p_wxEventTo_p_wxObject(void *x) {
56095 return (void *)((wxObject *) ((wxEvent *) x));
56096 }
56097 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
56098 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
56099 }
56100 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
56101 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
56102 }
56103 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
56104 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
56105 }
56106 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
56107 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
56108 }
56109 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
56110 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
56111 }
56112 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
56113 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
56114 }
56115 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
56116 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
56117 }
56118 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
56119 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
56120 }
56121 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
56122 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
56123 }
56124 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
56125 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
56126 }
56127 static void *_p_wxControlTo_p_wxObject(void *x) {
56128 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
56129 }
56130 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
56131 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
56132 }
56133 static void *_p_wxFSFileTo_p_wxObject(void *x) {
56134 return (void *)((wxObject *) ((wxFSFile *) x));
56135 }
56136 static void *_p_wxPySizerTo_p_wxObject(void *x) {
56137 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
56138 }
56139 static void *_p_wxPyEventTo_p_wxObject(void *x) {
56140 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
56141 }
56142 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
56143 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
56144 }
56145 static void *_p_wxShowEventTo_p_wxObject(void *x) {
56146 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
56147 }
56148 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
56149 return (void *)((wxObject *) ((wxMenuItem *) x));
56150 }
56151 static void *_p_wxDateEventTo_p_wxObject(void *x) {
56152 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
56153 }
56154 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
56155 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
56156 }
56157 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
56158 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
56159 }
56160 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
56161 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
56162 }
56163 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
56164 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
56165 }
56166 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
56167 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
56168 }
56169 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56170 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56171 }
56172 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56173 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56174 }
56175 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56176 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56177 }
56178 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56179 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56180 }
56181 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56182 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56183 }
56184 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56185 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56186 }
56187 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56188 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56189 }
56190 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56191 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56192 }
56193 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56194 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56195 }
56196 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56197 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56198 }
56199 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56200 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56201 }
56202 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56203 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56204 }
56205 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56206 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56207 }
56208 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56209 return (void *)((wxObject *) ((wxImageHandler *) x));
56210 }
56211 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56212 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56213 }
56214 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56215 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56216 }
56217 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56218 return (void *)((wxObject *) ((wxEvtHandler *) x));
56219 }
56220 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56221 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56222 }
56223 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56224 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56225 }
56226 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56227 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56228 }
56229 static void *_p_wxImageTo_p_wxObject(void *x) {
56230 return (void *)((wxObject *) ((wxImage *) x));
56231 }
56232 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56233 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56234 }
56235 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56236 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56237 }
56238 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56239 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56240 }
56241 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56242 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56243 }
56244 static void *_p_wxWindowTo_p_wxObject(void *x) {
56245 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56246 }
56247 static void *_p_wxMenuTo_p_wxObject(void *x) {
56248 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56249 }
56250 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56251 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56252 }
56253 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56254 return (void *)((wxObject *) ((wxFileSystem *) x));
56255 }
56256 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56257 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56258 }
56259 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56260 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56261 }
56262 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56263 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56264 }
56265 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56266 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56267 }
56268 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56269 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56270 }
56271 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56272 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56273 }
56274 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56275 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56276 }
56277 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56278 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56279 }
56280 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56281 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56282 }
56283 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56284 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56285 }
56286 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56287 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56288 }
56289 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56290 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56291 }
56292 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56293 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56294 }
56295 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56296 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56297 }
56298 static void *_p_wxControlTo_p_wxWindow(void *x) {
56299 return (void *)((wxWindow *) ((wxControl *) x));
56300 }
56301 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56302 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56303 }
56304 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56305 return (void *)((wxWindow *) ((wxMenuBar *) x));
56306 }
56307 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56308 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56309 }
56310 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56311 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56312 }
56313 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56314 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56315 }
56316 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56317 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56318 }
56319 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56320 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56321 }
56322 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56323 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56324 }
56325 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56326 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56327 }
56328 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56329 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56330 }
56331 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56332 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56333 }
56334 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56335 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56336 }
56337 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56338 return (void *)((wxValidator *) ((wxPyValidator *) x));
56339 }
56340 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56341 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56342 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};
56343 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56344 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56345 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56346 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56347 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56348 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56349 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56350 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56351 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56352 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56353 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56354 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56355 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56356 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56357 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56358 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56359 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56360 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56361 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56362 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56363 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56364 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56365 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56366 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56367 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56368 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56369 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56370 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56371 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56372 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56373 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56374 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56375 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56376 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56377 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56378 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56379 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56380 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56381 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56382 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56383 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56384 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56385 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56386 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56387 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56388 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56389 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56390 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56391 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56392 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56393 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56394 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56395 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56396 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56397 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56398 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56399 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56400 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56401 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56402 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56403 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56404 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56405 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56406 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56407 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56408 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56409 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56410 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56411 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56412 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56413 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56414 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56415 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56416 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56417 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56418 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56419 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56420 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56421 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56422 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56423 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56424 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56425 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56426 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56427 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56428 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56429 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56430 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56431 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56432 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56433 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56434 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56435 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56436 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56437 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56438 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56439 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56440 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56441 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56442 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56443 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56444 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56445 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56446 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56447 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56448 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56449 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56450 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56451 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56452 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56453 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56454 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56455 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56456 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56457 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56458 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56459 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56460 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56461 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56462 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56463 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56464 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56465 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56466 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56467 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56468 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56469 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56470 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56471 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56472
56473 static swig_type_info *swig_type_initial[] = {
56474 &_swigt__p_buffer,
56475 &_swigt__p_char,
56476 &_swigt__p_form_ops_t,
56477 &_swigt__p_int,
56478 &_swigt__p_long,
56479 &_swigt__p_unsigned_char,
56480 &_swigt__p_unsigned_int,
56481 &_swigt__p_unsigned_long,
56482 &_swigt__p_wxANIHandler,
56483 &_swigt__p_wxAcceleratorEntry,
56484 &_swigt__p_wxAcceleratorTable,
56485 &_swigt__p_wxActivateEvent,
56486 &_swigt__p_wxAppTraits,
56487 &_swigt__p_wxArrayString,
56488 &_swigt__p_wxBMPHandler,
56489 &_swigt__p_wxBitmap,
56490 &_swigt__p_wxBoxSizer,
56491 &_swigt__p_wxButton,
56492 &_swigt__p_wxCURHandler,
56493 &_swigt__p_wxCaret,
56494 &_swigt__p_wxChildFocusEvent,
56495 &_swigt__p_wxClipboardTextEvent,
56496 &_swigt__p_wxCloseEvent,
56497 &_swigt__p_wxColour,
56498 &_swigt__p_wxCommandEvent,
56499 &_swigt__p_wxContextMenuEvent,
56500 &_swigt__p_wxControl,
56501 &_swigt__p_wxControlWithItems,
56502 &_swigt__p_wxCursor,
56503 &_swigt__p_wxDC,
56504 &_swigt__p_wxDateEvent,
56505 &_swigt__p_wxDateTime,
56506 &_swigt__p_wxDisplayChangedEvent,
56507 &_swigt__p_wxDropFilesEvent,
56508 &_swigt__p_wxDuplexMode,
56509 &_swigt__p_wxEraseEvent,
56510 &_swigt__p_wxEvent,
56511 &_swigt__p_wxEventLoop,
56512 &_swigt__p_wxEventLoopActivator,
56513 &_swigt__p_wxEvtHandler,
56514 &_swigt__p_wxFSFile,
56515 &_swigt__p_wxFileSystem,
56516 &_swigt__p_wxFileSystemHandler,
56517 &_swigt__p_wxFlexGridSizer,
56518 &_swigt__p_wxFocusEvent,
56519 &_swigt__p_wxFont,
56520 &_swigt__p_wxFrame,
56521 &_swigt__p_wxGBPosition,
56522 &_swigt__p_wxGBSizerItem,
56523 &_swigt__p_wxGBSpan,
56524 &_swigt__p_wxGIFHandler,
56525 &_swigt__p_wxGridBagSizer,
56526 &_swigt__p_wxGridSizer,
56527 &_swigt__p_wxHelpEvent__Origin,
56528 &_swigt__p_wxICOHandler,
56529 &_swigt__p_wxIconizeEvent,
56530 &_swigt__p_wxIdleEvent,
56531 &_swigt__p_wxImage,
56532 &_swigt__p_wxImageHandler,
56533 &_swigt__p_wxImageHistogram,
56534 &_swigt__p_wxImage_HSVValue,
56535 &_swigt__p_wxImage_RGBValue,
56536 &_swigt__p_wxIndividualLayoutConstraint,
56537 &_swigt__p_wxInitDialogEvent,
56538 &_swigt__p_wxInputStream,
56539 &_swigt__p_wxInternetFSHandler,
56540 &_swigt__p_wxItemContainer,
56541 &_swigt__p_wxJPEGHandler,
56542 &_swigt__p_wxKeyEvent,
56543 &_swigt__p_wxLayoutConstraints,
56544 &_swigt__p_wxMaximizeEvent,
56545 &_swigt__p_wxMemoryFSHandler,
56546 &_swigt__p_wxMenu,
56547 &_swigt__p_wxMenuBar,
56548 &_swigt__p_wxMenuBarBase,
56549 &_swigt__p_wxMenuEvent,
56550 &_swigt__p_wxMenuItem,
56551 &_swigt__p_wxMouseCaptureChangedEvent,
56552 &_swigt__p_wxMouseCaptureLostEvent,
56553 &_swigt__p_wxMouseEvent,
56554 &_swigt__p_wxMoveEvent,
56555 &_swigt__p_wxNavigationKeyEvent,
56556 &_swigt__p_wxNcPaintEvent,
56557 &_swigt__p_wxNotifyEvent,
56558 &_swigt__p_wxObject,
56559 &_swigt__p_wxOutputStream,
56560 &_swigt__p_wxPCXHandler,
56561 &_swigt__p_wxPNGHandler,
56562 &_swigt__p_wxPNMHandler,
56563 &_swigt__p_wxPaintEvent,
56564 &_swigt__p_wxPaletteChangedEvent,
56565 &_swigt__p_wxPaperSize,
56566 &_swigt__p_wxPoint,
56567 &_swigt__p_wxPoint2D,
56568 &_swigt__p_wxPropagateOnce,
56569 &_swigt__p_wxPropagationDisabler,
56570 &_swigt__p_wxPyApp,
56571 &_swigt__p_wxPyCommandEvent,
56572 &_swigt__p_wxPyDropTarget,
56573 &_swigt__p_wxPyEvent,
56574 &_swigt__p_wxPyFileSystemHandler,
56575 &_swigt__p_wxPyImageHandler,
56576 &_swigt__p_wxPyInputStream,
56577 &_swigt__p_wxPySizer,
56578 &_swigt__p_wxPyValidator,
56579 &_swigt__p_wxQuantize,
56580 &_swigt__p_wxQueryNewPaletteEvent,
56581 &_swigt__p_wxRealPoint,
56582 &_swigt__p_wxRect,
56583 &_swigt__p_wxRegion,
56584 &_swigt__p_wxScrollEvent,
56585 &_swigt__p_wxScrollWinEvent,
56586 &_swigt__p_wxSetCursorEvent,
56587 &_swigt__p_wxShowEvent,
56588 &_swigt__p_wxSize,
56589 &_swigt__p_wxSizeEvent,
56590 &_swigt__p_wxSizer,
56591 &_swigt__p_wxSizerItem,
56592 &_swigt__p_wxStaticBox,
56593 &_swigt__p_wxStaticBoxSizer,
56594 &_swigt__p_wxStdDialogButtonSizer,
56595 &_swigt__p_wxSysColourChangedEvent,
56596 &_swigt__p_wxTIFFHandler,
56597 &_swigt__p_wxToolTip,
56598 &_swigt__p_wxUpdateUIEvent,
56599 &_swigt__p_wxValidator,
56600 &_swigt__p_wxVisualAttributes,
56601 &_swigt__p_wxWindow,
56602 &_swigt__p_wxWindowCreateEvent,
56603 &_swigt__p_wxWindowDestroyEvent,
56604 &_swigt__p_wxXPMHandler,
56605 &_swigt__p_wxZipFSHandler,
56606 };
56607
56608 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56609 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56610 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56611 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56612 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56613 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56614 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56615 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56616 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56617 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56618 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56619 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56620 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56621 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56622 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}};
56623 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56624 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}};
56625 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56626 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}};
56627 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56628 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56629 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56630 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56631 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56632 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}};
56633 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56634 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}};
56635 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56636 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56637 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56638 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56639 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56640 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56641 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56642 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56643 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56644 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
56645 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56646 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56647 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}};
56648 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56649 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56650 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}};
56651 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}};
56652 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56653 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56654 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56655 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56656 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56657 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56658 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56659 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56660 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}};
56661 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56662 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}};
56663 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56664 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56665 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56666 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}};
56667 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56668 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56669 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56670 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56671 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56672 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56673 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56674 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}};
56675 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56676 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56677 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56678 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56679 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56680 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56681 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56682 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56683 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56684 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56685 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56686 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56687 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56688 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56689 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56690 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56691 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56692 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56693 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56694 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56695 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56696 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56697 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56698 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56699 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56700 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56701 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56702 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56703 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56704 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56705 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56706 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56707 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56708 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56709 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56710 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56711 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56712 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56713 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56714 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56715 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56716 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56717 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56718 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56719 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56720 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56721 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56722 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56723 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56724 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}};
56725 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}};
56726 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56727 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56728 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56729 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56730 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56731 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56732 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56733 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}};
56734 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56735 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}};
56736 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56737 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56738 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56739 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56740
56741 static swig_cast_info *swig_cast_initial[] = {
56742 _swigc__p_buffer,
56743 _swigc__p_char,
56744 _swigc__p_form_ops_t,
56745 _swigc__p_int,
56746 _swigc__p_long,
56747 _swigc__p_unsigned_char,
56748 _swigc__p_unsigned_int,
56749 _swigc__p_unsigned_long,
56750 _swigc__p_wxANIHandler,
56751 _swigc__p_wxAcceleratorEntry,
56752 _swigc__p_wxAcceleratorTable,
56753 _swigc__p_wxActivateEvent,
56754 _swigc__p_wxAppTraits,
56755 _swigc__p_wxArrayString,
56756 _swigc__p_wxBMPHandler,
56757 _swigc__p_wxBitmap,
56758 _swigc__p_wxBoxSizer,
56759 _swigc__p_wxButton,
56760 _swigc__p_wxCURHandler,
56761 _swigc__p_wxCaret,
56762 _swigc__p_wxChildFocusEvent,
56763 _swigc__p_wxClipboardTextEvent,
56764 _swigc__p_wxCloseEvent,
56765 _swigc__p_wxColour,
56766 _swigc__p_wxCommandEvent,
56767 _swigc__p_wxContextMenuEvent,
56768 _swigc__p_wxControl,
56769 _swigc__p_wxControlWithItems,
56770 _swigc__p_wxCursor,
56771 _swigc__p_wxDC,
56772 _swigc__p_wxDateEvent,
56773 _swigc__p_wxDateTime,
56774 _swigc__p_wxDisplayChangedEvent,
56775 _swigc__p_wxDropFilesEvent,
56776 _swigc__p_wxDuplexMode,
56777 _swigc__p_wxEraseEvent,
56778 _swigc__p_wxEvent,
56779 _swigc__p_wxEventLoop,
56780 _swigc__p_wxEventLoopActivator,
56781 _swigc__p_wxEvtHandler,
56782 _swigc__p_wxFSFile,
56783 _swigc__p_wxFileSystem,
56784 _swigc__p_wxFileSystemHandler,
56785 _swigc__p_wxFlexGridSizer,
56786 _swigc__p_wxFocusEvent,
56787 _swigc__p_wxFont,
56788 _swigc__p_wxFrame,
56789 _swigc__p_wxGBPosition,
56790 _swigc__p_wxGBSizerItem,
56791 _swigc__p_wxGBSpan,
56792 _swigc__p_wxGIFHandler,
56793 _swigc__p_wxGridBagSizer,
56794 _swigc__p_wxGridSizer,
56795 _swigc__p_wxHelpEvent__Origin,
56796 _swigc__p_wxICOHandler,
56797 _swigc__p_wxIconizeEvent,
56798 _swigc__p_wxIdleEvent,
56799 _swigc__p_wxImage,
56800 _swigc__p_wxImageHandler,
56801 _swigc__p_wxImageHistogram,
56802 _swigc__p_wxImage_HSVValue,
56803 _swigc__p_wxImage_RGBValue,
56804 _swigc__p_wxIndividualLayoutConstraint,
56805 _swigc__p_wxInitDialogEvent,
56806 _swigc__p_wxInputStream,
56807 _swigc__p_wxInternetFSHandler,
56808 _swigc__p_wxItemContainer,
56809 _swigc__p_wxJPEGHandler,
56810 _swigc__p_wxKeyEvent,
56811 _swigc__p_wxLayoutConstraints,
56812 _swigc__p_wxMaximizeEvent,
56813 _swigc__p_wxMemoryFSHandler,
56814 _swigc__p_wxMenu,
56815 _swigc__p_wxMenuBar,
56816 _swigc__p_wxMenuBarBase,
56817 _swigc__p_wxMenuEvent,
56818 _swigc__p_wxMenuItem,
56819 _swigc__p_wxMouseCaptureChangedEvent,
56820 _swigc__p_wxMouseCaptureLostEvent,
56821 _swigc__p_wxMouseEvent,
56822 _swigc__p_wxMoveEvent,
56823 _swigc__p_wxNavigationKeyEvent,
56824 _swigc__p_wxNcPaintEvent,
56825 _swigc__p_wxNotifyEvent,
56826 _swigc__p_wxObject,
56827 _swigc__p_wxOutputStream,
56828 _swigc__p_wxPCXHandler,
56829 _swigc__p_wxPNGHandler,
56830 _swigc__p_wxPNMHandler,
56831 _swigc__p_wxPaintEvent,
56832 _swigc__p_wxPaletteChangedEvent,
56833 _swigc__p_wxPaperSize,
56834 _swigc__p_wxPoint,
56835 _swigc__p_wxPoint2D,
56836 _swigc__p_wxPropagateOnce,
56837 _swigc__p_wxPropagationDisabler,
56838 _swigc__p_wxPyApp,
56839 _swigc__p_wxPyCommandEvent,
56840 _swigc__p_wxPyDropTarget,
56841 _swigc__p_wxPyEvent,
56842 _swigc__p_wxPyFileSystemHandler,
56843 _swigc__p_wxPyImageHandler,
56844 _swigc__p_wxPyInputStream,
56845 _swigc__p_wxPySizer,
56846 _swigc__p_wxPyValidator,
56847 _swigc__p_wxQuantize,
56848 _swigc__p_wxQueryNewPaletteEvent,
56849 _swigc__p_wxRealPoint,
56850 _swigc__p_wxRect,
56851 _swigc__p_wxRegion,
56852 _swigc__p_wxScrollEvent,
56853 _swigc__p_wxScrollWinEvent,
56854 _swigc__p_wxSetCursorEvent,
56855 _swigc__p_wxShowEvent,
56856 _swigc__p_wxSize,
56857 _swigc__p_wxSizeEvent,
56858 _swigc__p_wxSizer,
56859 _swigc__p_wxSizerItem,
56860 _swigc__p_wxStaticBox,
56861 _swigc__p_wxStaticBoxSizer,
56862 _swigc__p_wxStdDialogButtonSizer,
56863 _swigc__p_wxSysColourChangedEvent,
56864 _swigc__p_wxTIFFHandler,
56865 _swigc__p_wxToolTip,
56866 _swigc__p_wxUpdateUIEvent,
56867 _swigc__p_wxValidator,
56868 _swigc__p_wxVisualAttributes,
56869 _swigc__p_wxWindow,
56870 _swigc__p_wxWindowCreateEvent,
56871 _swigc__p_wxWindowDestroyEvent,
56872 _swigc__p_wxXPMHandler,
56873 _swigc__p_wxZipFSHandler,
56874 };
56875
56876
56877 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56878
56879 static swig_const_info swig_const_table[] = {
56880 {0, 0, 0, 0.0, 0, 0}};
56881
56882 #ifdef __cplusplus
56883 }
56884 #endif
56885 /* -----------------------------------------------------------------------------
56886 * Type initialization:
56887 * This problem is tough by the requirement that no dynamic
56888 * memory is used. Also, since swig_type_info structures store pointers to
56889 * swig_cast_info structures and swig_cast_info structures store pointers back
56890 * to swig_type_info structures, we need some lookup code at initialization.
56891 * The idea is that swig generates all the structures that are needed.
56892 * The runtime then collects these partially filled structures.
56893 * The SWIG_InitializeModule function takes these initial arrays out of
56894 * swig_module, and does all the lookup, filling in the swig_module.types
56895 * array with the correct data and linking the correct swig_cast_info
56896 * structures together.
56897 *
56898 * The generated swig_type_info structures are assigned staticly to an initial
56899 * array. We just loop though that array, and handle each type individually.
56900 * First we lookup if this type has been already loaded, and if so, use the
56901 * loaded structure instead of the generated one. Then we have to fill in the
56902 * cast linked list. The cast data is initially stored in something like a
56903 * two-dimensional array. Each row corresponds to a type (there are the same
56904 * number of rows as there are in the swig_type_initial array). Each entry in
56905 * a column is one of the swig_cast_info structures for that type.
56906 * The cast_initial array is actually an array of arrays, because each row has
56907 * a variable number of columns. So to actually build the cast linked list,
56908 * we find the array of casts associated with the type, and loop through it
56909 * adding the casts to the list. The one last trick we need to do is making
56910 * sure the type pointer in the swig_cast_info struct is correct.
56911 *
56912 * First off, we lookup the cast->type name to see if it is already loaded.
56913 * There are three cases to handle:
56914 * 1) If the cast->type has already been loaded AND the type we are adding
56915 * casting info to has not been loaded (it is in this module), THEN we
56916 * replace the cast->type pointer with the type pointer that has already
56917 * been loaded.
56918 * 2) If BOTH types (the one we are adding casting info to, and the
56919 * cast->type) are loaded, THEN the cast info has already been loaded by
56920 * the previous module so we just ignore it.
56921 * 3) Finally, if cast->type has not already been loaded, then we add that
56922 * swig_cast_info to the linked list (because the cast->type) pointer will
56923 * be correct.
56924 * ----------------------------------------------------------------------------- */
56925
56926 #ifdef __cplusplus
56927 extern "C" {
56928 #if 0
56929 } /* c-mode */
56930 #endif
56931 #endif
56932
56933 #if 0
56934 #define SWIGRUNTIME_DEBUG
56935 #endif
56936
56937 SWIGRUNTIME void
56938 SWIG_InitializeModule(void *clientdata) {
56939 size_t i;
56940 swig_module_info *module_head;
56941 static int init_run = 0;
56942
56943 clientdata = clientdata;
56944
56945 if (init_run) return;
56946 init_run = 1;
56947
56948 /* Initialize the swig_module */
56949 swig_module.type_initial = swig_type_initial;
56950 swig_module.cast_initial = swig_cast_initial;
56951
56952 /* Try and load any already created modules */
56953 module_head = SWIG_GetModule(clientdata);
56954 if (module_head) {
56955 swig_module.next = module_head->next;
56956 module_head->next = &swig_module;
56957 } else {
56958 /* This is the first module loaded */
56959 swig_module.next = &swig_module;
56960 SWIG_SetModule(clientdata, &swig_module);
56961 }
56962
56963 /* Now work on filling in swig_module.types */
56964 #ifdef SWIGRUNTIME_DEBUG
56965 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56966 #endif
56967 for (i = 0; i < swig_module.size; ++i) {
56968 swig_type_info *type = 0;
56969 swig_type_info *ret;
56970 swig_cast_info *cast;
56971
56972 #ifdef SWIGRUNTIME_DEBUG
56973 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56974 #endif
56975
56976 /* if there is another module already loaded */
56977 if (swig_module.next != &swig_module) {
56978 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56979 }
56980 if (type) {
56981 /* Overwrite clientdata field */
56982 #ifdef SWIGRUNTIME_DEBUG
56983 printf("SWIG_InitializeModule: found type %s\n", type->name);
56984 #endif
56985 if (swig_module.type_initial[i]->clientdata) {
56986 type->clientdata = swig_module.type_initial[i]->clientdata;
56987 #ifdef SWIGRUNTIME_DEBUG
56988 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56989 #endif
56990 }
56991 } else {
56992 type = swig_module.type_initial[i];
56993 }
56994
56995 /* Insert casting types */
56996 cast = swig_module.cast_initial[i];
56997 while (cast->type) {
56998 /* Don't need to add information already in the list */
56999 ret = 0;
57000 #ifdef SWIGRUNTIME_DEBUG
57001 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
57002 #endif
57003 if (swig_module.next != &swig_module) {
57004 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
57005 #ifdef SWIGRUNTIME_DEBUG
57006 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
57007 #endif
57008 }
57009 if (ret) {
57010 if (type == swig_module.type_initial[i]) {
57011 #ifdef SWIGRUNTIME_DEBUG
57012 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
57013 #endif
57014 cast->type = ret;
57015 ret = 0;
57016 } else {
57017 /* Check for casting already in the list */
57018 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
57019 #ifdef SWIGRUNTIME_DEBUG
57020 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
57021 #endif
57022 if (!ocast) ret = 0;
57023 }
57024 }
57025
57026 if (!ret) {
57027 #ifdef SWIGRUNTIME_DEBUG
57028 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
57029 #endif
57030 if (type->cast) {
57031 type->cast->prev = cast;
57032 cast->next = type->cast;
57033 }
57034 type->cast = cast;
57035 }
57036 cast++;
57037 }
57038 /* Set entry in modules->types array equal to the type */
57039 swig_module.types[i] = type;
57040 }
57041 swig_module.types[i] = 0;
57042
57043 #ifdef SWIGRUNTIME_DEBUG
57044 printf("**** SWIG_InitializeModule: Cast List ******\n");
57045 for (i = 0; i < swig_module.size; ++i) {
57046 int j = 0;
57047 swig_cast_info *cast = swig_module.cast_initial[i];
57048 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
57049 while (cast->type) {
57050 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
57051 cast++;
57052 ++j;
57053 }
57054 printf("---- Total casts: %d\n",j);
57055 }
57056 printf("**** SWIG_InitializeModule: Cast List ******\n");
57057 #endif
57058 }
57059
57060 /* This function will propagate the clientdata field of type to
57061 * any new swig_type_info structures that have been added into the list
57062 * of equivalent types. It is like calling
57063 * SWIG_TypeClientData(type, clientdata) a second time.
57064 */
57065 SWIGRUNTIME void
57066 SWIG_PropagateClientData(void) {
57067 size_t i;
57068 swig_cast_info *equiv;
57069 static int init_run = 0;
57070
57071 if (init_run) return;
57072 init_run = 1;
57073
57074 for (i = 0; i < swig_module.size; i++) {
57075 if (swig_module.types[i]->clientdata) {
57076 equiv = swig_module.types[i]->cast;
57077 while (equiv) {
57078 if (!equiv->converter) {
57079 if (equiv->type && !equiv->type->clientdata)
57080 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
57081 }
57082 equiv = equiv->next;
57083 }
57084 }
57085 }
57086 }
57087
57088 #ifdef __cplusplus
57089 #if 0
57090 {
57091 /* c-mode */
57092 #endif
57093 }
57094 #endif
57095
57096
57097
57098 #ifdef __cplusplus
57099 extern "C" {
57100 #endif
57101
57102 /* Python-specific SWIG API */
57103 #define SWIG_newvarlink() SWIG_Python_newvarlink()
57104 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
57105 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
57106
57107 /* -----------------------------------------------------------------------------
57108 * global variable support code.
57109 * ----------------------------------------------------------------------------- */
57110
57111 typedef struct swig_globalvar {
57112 char *name; /* Name of global variable */
57113 PyObject *(*get_attr)(void); /* Return the current value */
57114 int (*set_attr)(PyObject *); /* Set the value */
57115 struct swig_globalvar *next;
57116 } swig_globalvar;
57117
57118 typedef struct swig_varlinkobject {
57119 PyObject_HEAD
57120 swig_globalvar *vars;
57121 } swig_varlinkobject;
57122
57123 SWIGINTERN PyObject *
57124 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
57125 return PyString_FromString("<Swig global variables>");
57126 }
57127
57128 SWIGINTERN PyObject *
57129 swig_varlink_str(swig_varlinkobject *v) {
57130 PyObject *str = PyString_FromString("(");
57131 swig_globalvar *var;
57132 for (var = v->vars; var; var=var->next) {
57133 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
57134 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
57135 }
57136 PyString_ConcatAndDel(&str,PyString_FromString(")"));
57137 return str;
57138 }
57139
57140 SWIGINTERN int
57141 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
57142 PyObject *str = swig_varlink_str(v);
57143 fprintf(fp,"Swig global variables ");
57144 fprintf(fp,"%s\n", PyString_AsString(str));
57145 Py_DECREF(str);
57146 return 0;
57147 }
57148
57149 SWIGINTERN void
57150 swig_varlink_dealloc(swig_varlinkobject *v) {
57151 swig_globalvar *var = v->vars;
57152 while (var) {
57153 swig_globalvar *n = var->next;
57154 free(var->name);
57155 free(var);
57156 var = n;
57157 }
57158 }
57159
57160 SWIGINTERN PyObject *
57161 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
57162 PyObject *res = NULL;
57163 swig_globalvar *var = v->vars;
57164 while (var) {
57165 if (strcmp(var->name,n) == 0) {
57166 res = (*var->get_attr)();
57167 break;
57168 }
57169 var = var->next;
57170 }
57171 if (res == NULL && !PyErr_Occurred()) {
57172 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57173 }
57174 return res;
57175 }
57176
57177 SWIGINTERN int
57178 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57179 int res = 1;
57180 swig_globalvar *var = v->vars;
57181 while (var) {
57182 if (strcmp(var->name,n) == 0) {
57183 res = (*var->set_attr)(p);
57184 break;
57185 }
57186 var = var->next;
57187 }
57188 if (res == 1 && !PyErr_Occurred()) {
57189 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57190 }
57191 return res;
57192 }
57193
57194 SWIGINTERN PyTypeObject*
57195 swig_varlink_type(void) {
57196 static char varlink__doc__[] = "Swig var link object";
57197 static PyTypeObject varlink_type;
57198 static int type_init = 0;
57199 if (!type_init) {
57200 const PyTypeObject tmp
57201 = {
57202 PyObject_HEAD_INIT(NULL)
57203 0, /* Number of items in variable part (ob_size) */
57204 (char *)"swigvarlink", /* Type name (tp_name) */
57205 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57206 0, /* Itemsize (tp_itemsize) */
57207 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57208 (printfunc) swig_varlink_print, /* Print (tp_print) */
57209 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57210 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57211 0, /* tp_compare */
57212 (reprfunc) swig_varlink_repr, /* tp_repr */
57213 0, /* tp_as_number */
57214 0, /* tp_as_sequence */
57215 0, /* tp_as_mapping */
57216 0, /* tp_hash */
57217 0, /* tp_call */
57218 (reprfunc)swig_varlink_str, /* tp_str */
57219 0, /* tp_getattro */
57220 0, /* tp_setattro */
57221 0, /* tp_as_buffer */
57222 0, /* tp_flags */
57223 varlink__doc__, /* tp_doc */
57224 0, /* tp_traverse */
57225 0, /* tp_clear */
57226 0, /* tp_richcompare */
57227 0, /* tp_weaklistoffset */
57228 #if PY_VERSION_HEX >= 0x02020000
57229 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57230 #endif
57231 #if PY_VERSION_HEX >= 0x02030000
57232 0, /* tp_del */
57233 #endif
57234 #ifdef COUNT_ALLOCS
57235 0,0,0,0 /* tp_alloc -> tp_next */
57236 #endif
57237 };
57238 varlink_type = tmp;
57239 varlink_type.ob_type = &PyType_Type;
57240 type_init = 1;
57241 }
57242 return &varlink_type;
57243 }
57244
57245 /* Create a variable linking object for use later */
57246 SWIGINTERN PyObject *
57247 SWIG_Python_newvarlink(void) {
57248 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57249 if (result) {
57250 result->vars = 0;
57251 }
57252 return ((PyObject*) result);
57253 }
57254
57255 SWIGINTERN void
57256 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57257 swig_varlinkobject *v = (swig_varlinkobject *) p;
57258 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57259 if (gv) {
57260 size_t size = strlen(name)+1;
57261 gv->name = (char *)malloc(size);
57262 if (gv->name) {
57263 strncpy(gv->name,name,size);
57264 gv->get_attr = get_attr;
57265 gv->set_attr = set_attr;
57266 gv->next = v->vars;
57267 }
57268 }
57269 v->vars = gv;
57270 }
57271
57272 SWIGINTERN PyObject *
57273 SWIG_globals() {
57274 static PyObject *_SWIG_globals = 0;
57275 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57276 return _SWIG_globals;
57277 }
57278
57279 /* -----------------------------------------------------------------------------
57280 * constants/methods manipulation
57281 * ----------------------------------------------------------------------------- */
57282
57283 /* Install Constants */
57284 SWIGINTERN void
57285 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57286 PyObject *obj = 0;
57287 size_t i;
57288 for (i = 0; constants[i].type; ++i) {
57289 switch(constants[i].type) {
57290 case SWIG_PY_POINTER:
57291 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57292 break;
57293 case SWIG_PY_BINARY:
57294 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57295 break;
57296 default:
57297 obj = 0;
57298 break;
57299 }
57300 if (obj) {
57301 PyDict_SetItemString(d, constants[i].name, obj);
57302 Py_DECREF(obj);
57303 }
57304 }
57305 }
57306
57307 /* -----------------------------------------------------------------------------*/
57308 /* Fix SwigMethods to carry the callback ptrs when needed */
57309 /* -----------------------------------------------------------------------------*/
57310
57311 SWIGINTERN void
57312 SWIG_Python_FixMethods(PyMethodDef *methods,
57313 swig_const_info *const_table,
57314 swig_type_info **types,
57315 swig_type_info **types_initial) {
57316 size_t i;
57317 for (i = 0; methods[i].ml_name; ++i) {
57318 const char *c = methods[i].ml_doc;
57319 if (c && (c = strstr(c, "swig_ptr: "))) {
57320 int j;
57321 swig_const_info *ci = 0;
57322 const char *name = c + 10;
57323 for (j = 0; const_table[j].type; ++j) {
57324 if (strncmp(const_table[j].name, name,
57325 strlen(const_table[j].name)) == 0) {
57326 ci = &(const_table[j]);
57327 break;
57328 }
57329 }
57330 if (ci) {
57331 size_t shift = (ci->ptype) - types;
57332 swig_type_info *ty = types_initial[shift];
57333 size_t ldoc = (c - methods[i].ml_doc);
57334 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57335 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57336 if (ndoc) {
57337 char *buff = ndoc;
57338 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57339 if (ptr) {
57340 strncpy(buff, methods[i].ml_doc, ldoc);
57341 buff += ldoc;
57342 strncpy(buff, "swig_ptr: ", 10);
57343 buff += 10;
57344 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57345 methods[i].ml_doc = ndoc;
57346 }
57347 }
57348 }
57349 }
57350 }
57351 }
57352
57353 #ifdef __cplusplus
57354 }
57355 #endif
57356
57357 /* -----------------------------------------------------------------------------*
57358 * Partial Init method
57359 * -----------------------------------------------------------------------------*/
57360
57361 #ifdef __cplusplus
57362 extern "C"
57363 #endif
57364 SWIGEXPORT void SWIG_init(void) {
57365 PyObject *m, *d;
57366
57367 /* Fix SwigMethods to carry the callback ptrs when needed */
57368 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57369
57370 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57371 d = PyModule_GetDict(m);
57372
57373 SWIG_InitializeModule(0);
57374 SWIG_InstallConstants(d,swig_const_table);
57375
57376
57377
57378 #ifndef wxPyUSE_EXPORT
57379 // Make our API structure a CObject so other modules can import it
57380 // from this module.
57381 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57382 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57383 Py_XDECREF(cobj);
57384 #endif
57385
57386 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57387 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57388 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57389 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57390 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57391 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57392 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57393 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57394 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57395 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57396 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57397 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57398 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57399 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57400 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57401 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57402 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57403 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57404 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57405 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57406 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57407 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57408 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57409 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57410 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57411 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57412 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57413 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57414 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57415 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57416 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57417 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57418 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57419 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57420 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57421 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57422 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57423 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57424 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57425 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57426 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57427 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57428 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57429 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57430 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57431 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57432 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57433 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57434 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57435 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57436 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57437 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57438 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57439 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57440 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57441 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57442 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57443 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57444 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57445 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57446 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57447 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57448 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57449 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57450 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57451 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57452 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57453 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57454 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57455 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57456 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57457 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57458 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57459 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57460 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57461 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57462 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57463 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57464 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57465 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57466 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57467 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57468 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57469 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57470 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57471 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57472 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57473 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57474 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57475 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57476 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57477 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57478 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57479 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57480 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57481 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57482 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57483 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57484 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57485 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57486 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57487 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57488 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57489 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57490 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57491 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57492 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57493 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57494 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57495 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57496 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57497 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57498 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57499 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57500 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57501 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57502 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57503 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57504 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57505 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57506 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57507 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57508 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57509 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57510 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57511 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57512 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57513 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57514 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57515 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57516 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57517 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57518 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57519 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57520 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57521 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57522 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57523 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57524 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57525 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57526 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57527 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57528 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57529 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57530 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57531 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57532 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57533 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57534 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57535 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57536 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57537 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57538 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57539 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57540 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57541 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57542 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57543 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57544 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57545 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57546 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57547 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57548 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57549 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57550 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57551 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57552 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57553 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57554 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57555 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57556 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57557 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57558 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57559 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57560 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57561 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57562 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57563 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57564 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57565 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57566 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57567 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57568 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57569 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57570 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57571 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57572 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57573 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57574 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57575 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57576 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57577 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57578 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57579 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57580 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57581 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57582 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57583 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57584 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57585 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57586 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57587 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57588 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57589 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57590 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57591 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57592 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57593 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57594 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57595 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57596 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57597 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57598 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57599 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57600 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57601 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57602 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57603 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57604 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57605 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57606 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57607 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57608 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57609 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57610 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57611 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57612 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57613 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57614 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57615 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57616 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57617 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57618 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57619 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57620 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57621 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57622 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57623 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57624 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57625 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57626 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57627 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57628 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57629 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57630 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57631 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57632 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57633 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57634 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57635 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57636 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57637 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57638 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57639 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57640 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57641 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57642 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57643 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57644 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57645 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57646 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57647 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57648 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57649 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57650 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57651 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57652 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57653 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57654 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57655 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57656 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57657 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57658 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57659 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57660 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57661 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57662 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57663 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57664 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57665 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57666 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57667 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57668 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57669 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57670 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57671 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57672 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57673 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57674 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57675 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57676 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57677 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57678 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57679 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57680 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57681 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57682 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57683 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57684 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57685 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57686 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57687 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57688 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57689 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57690 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57691 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57692 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57693 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57694 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57695 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57696 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57697 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57698 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57699 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57700 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57701 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57702 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57703 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57704 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57705 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57706 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57707 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57708 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57709 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57710 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57711 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57712 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57713 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57714 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57715 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57716 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57717 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57718 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57719 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57720 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57721 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57722 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57723 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57724 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57725 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57726 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57727 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57728 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57729 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57730 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57731 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57732 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57733 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57734 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57735 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57736 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57737 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57738 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57739 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57740 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57741 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57742 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57743 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57744 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57745 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57746 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57747 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57748 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57749 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57750 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57751 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57752 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57753 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57754 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57755 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57756 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57757 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57758 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57759 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57760 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57761 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57762 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57763 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57764 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57765 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57766 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57767 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57768 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57769 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57770 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57771 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57772 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57773 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57774 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57775 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57776 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57777 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57778 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57779 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57780 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57781 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57782 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57783 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57784 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57785 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57786 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57787 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57788 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57789 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57790 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57791 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57792 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57793 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57794 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57795 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57796 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57797 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57798 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57799 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57800 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57801 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57802 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57803 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57804 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57805 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57806 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57807 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57808 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57809 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57810 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57811 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57812 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57813 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57814 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57815 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57816 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57817 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57818 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57819 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57820 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57821 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57822 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57823 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57824 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57825 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57826 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57827 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57828 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57829 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57830 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57831 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57832 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57833 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57834 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57835 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57836 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57837 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57838 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57839 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57840 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57841 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57842 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57843 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57844 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57845 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57846 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57847 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57848 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57849 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57850 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57851 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57852 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57853 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57854 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57855 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57856 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57857 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57858 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57859 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57860 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57861 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57862 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57863 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57864 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57865 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57866 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57867 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57868 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57869 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57870 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57871 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57872 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57873 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57874 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57875 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57876 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57877 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57878 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57879 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57880 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57881 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57882 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57883 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57884 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57885 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57886 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57887 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57888 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57889 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57890 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57891 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57892 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57893 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57894 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57895 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57896 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57897 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57898 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57899 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57900 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57901 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57902 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57903 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57904 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57905 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57906 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57907 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57908 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57909 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57910 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57911 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57912 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57913 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57914 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57915 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57916 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57917 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57918 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57919 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57920 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57921 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57922 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57923 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57924 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57925 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57926 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57927 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57928 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57929 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57930 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57931 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57932 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57933 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57934 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57935 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57936 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57937 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57938 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57939 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57940 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57941 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57942 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57943 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57944 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57945 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57946 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57947 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57948 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57949 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57950 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57951 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57952 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57953 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57954 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57955 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57956 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57957 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57958 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57959 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57960 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57961 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57962 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57963 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57964 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57965 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57966 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57967 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57968 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57969 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57970 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57971 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57972 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57973 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57974 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57975 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57976 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57977 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57978 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57979 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57980 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57981 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57982 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57983 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57984 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57985 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57986 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57987 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57988 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57989 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57990 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57991 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57992 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57993 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57994 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57995 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57996 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57997 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57998 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57999 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
58000 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
58001 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
58002 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
58003 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
58004 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
58005 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
58006 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
58007 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
58008 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
58009 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
58010 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
58011 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
58012 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
58013 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
58014 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
58015 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
58016 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
58017 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
58018 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
58019 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
58020 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
58021 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
58022 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
58023 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
58024 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
58025 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
58026 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
58027 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
58028 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
58029 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
58030 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
58031 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
58032 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
58033 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
58034 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
58035 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
58036 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
58037 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
58038 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
58039 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
58040 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
58041 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
58042 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
58043 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
58044 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
58045
58046 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
58047
58048
58049 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
58050
58051 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
58052 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
58053 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
58054 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
58055 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
58056 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
58057 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
58058 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
58059 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
58060 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
58061 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
58062 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
58063 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
58064 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
58065 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
58066 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
58067 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
58068 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
58069 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
58070 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
58071 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
58072 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
58073 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
58074 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
58075 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
58076 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
58077 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
58078 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
58079 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
58080 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
58081 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
58082 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
58083 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
58084 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
58085 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
58086 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
58087 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
58088 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
58089 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
58090 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
58091 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
58092 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
58093 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
58094 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
58095 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
58096 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
58097 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
58098 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
58099 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
58100 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
58101 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
58102 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
58103 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
58104 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
58105 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
58106 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
58107 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
58108 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
58109 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
58110 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
58111 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
58112 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
58113 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
58114 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
58115 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
58116 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
58117 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
58118 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
58119 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
58120 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
58121 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
58122 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
58123 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
58124 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
58125 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
58126 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
58127 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
58128 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
58129 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
58130 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
58131 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
58132 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
58133 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
58134 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
58135 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
58136 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
58137 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
58138 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
58139 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
58140 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
58141 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
58142 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
58143 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
58144 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
58145 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
58146 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
58147 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
58148 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
58149 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
58150 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
58151 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
58152 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
58153 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
58154 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
58155 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
58156 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
58157 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
58158 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
58159 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
58160 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
58161 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
58162 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
58163 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
58164 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
58165 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
58166 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
58167 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
58168 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
58169 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58170 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58171 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58172 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58173 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58174 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58175 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58176 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58177 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58178 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58179 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58180 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58181 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58182 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58183 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58184 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58185 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58186 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58187 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58188 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58189 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58190 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58191 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58192 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58193 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58194 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58195 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58196 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58197 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58198 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58199 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58200 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58201 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58202 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58203 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58204 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58205 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58206 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58207 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58208 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58209 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58210 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58211 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58212 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58213 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58214 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58215 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58216 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58217 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58218 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58219 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58220 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58221 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58222 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58223 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58224 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58225 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58226 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58227 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58228 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58229 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58230 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58231 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58232 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58233 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58234 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58235 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58236 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58237 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58238 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58239 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58240 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58241 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58242 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58243 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58244 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58245 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58246 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58247 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58248 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58249 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58250 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58251 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58252 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58253 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58254 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58255 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58256 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58257 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58258 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58259 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58260 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58261 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58262 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58263 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58264 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58265
58266 // Initialize threading, some globals and such
58267 __wxPyPreStart(d);
58268
58269
58270 // Although these are defined in __version__ they need to be here too so
58271 // that an assert can be done to ensure that the wxPython and the wxWindows
58272 // versions match.
58273 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58274 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58275 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58276
58277 }
58278
wxWidgets (Impactor)